Java基础(五)面对对象

2018-06-18 03:29:06来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

一、面向对象

  面向对象 : 就是一种编程思想

1、类和对象

  是指描述一类事物,或者看成是一个分类,可以把类看作构造对象的模板。

  对象是指具体的个体(也叫实例-instance)。创建对象使用 new,没对象就 new 一个对象。

1、设计类

语法:

1 class 类名{
2     成员变量  (字段)
3     方法 (具体的一个功能行为)   
4 }

类规范书写:

            ①类名首字符大写;

            ②类名必须具有意义;

            ③必须写注释;

1 public class Car {
2     String name;  //字段
3     Integer price;
4 
5     void run(){  //方法,具体行为
6         System.out.println("run");
7     }
8 }

2、构造方法

  创建对象本质上是调用类的构造方法。

 1 public class Car {
 2     String name;  //字段
 3     Integer price;
 4 
 5     void run(){  //方法,具体行为
 6         System.out.println("run");
 7     }
 8 
 9     //构造方法,无参构造方法
10     public Car() {
11     }
12 }

特点:

1、每一个类中都至少有一个构造方法;如果没有看到(显示的),那么存在一个隐式的无参数的构造方法;如果一个类中有显示的构造方法,那么隐式的就不存在了

2、构造方法的名字和类名一致(包括大小写完全一致)。

3、没有返回值类型,构造方法内部不需要返回任何的数据。

4、其他的和普通方法类型 ,可以有修饰(public),可以有形参列表,可以有方法体。

5、在创建对象的同时给对象的字段赋值,有参数的构造方法的作用。

6、构造器总是伴随着new操作一起调用的。

 1 public class Car {
 2     String name;  //字段
 3     Integer price;
 4 
 5     void run(){  //方法,具体行为
 6         System.out.println("run");
 7     }
 8 
 9     //构造方法
10     public Car() {
11     }
12 
13     //有参构造方法
14     public Car(String name, Integer price) {  //在创建对象的同时给对象的字段赋值
15         this.name = name;
16         this.price = price;
17     }
18 }

3、封装

  在面向对象程式设计方法中,封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法(数据隐藏)。

Java 中的体现

1 把类中的字段(实例域)私有化;

2 给每一个字段都提供一组getter, setter方法  (方法的规范写法);

3 在测试类中尝试创建对象,并通过调用getter setter方法完成对字段的赋值和取值;

优点:

  适当的封装可以让代码更容易理解与维护,也加强了代码的安全性。减少耦合。类内部的结构可以自由修改。可以对成员变量进行更精确的控制。隐藏信息,实现细节。

 1 public class Student {
 2     private String name;  //私有化字段
 3     private Integer age;
 4 
 5     //getter和setter方法
 6     public String getName() {
 7         return name;
 8     }
 9 
10     public void setName(String name) {
11         this.name = name;
12     }
13 
14     public Integer getAge() {
15         return age;
16     }
17 
18     public void setAge(Integer age) {
19         this.age = age;
20     }
21 }

this介绍:

  setter方法,里面参数名称都一样的时候,就选择就近原则;使用this。

4、继承

1、具体实现

  提高了代码的维护性和复用性,并且让代码更加简洁。

Java类中的继承的语法格式

1 class A{ }
2 
3 class B extends A{ }

  A 是 B 的父类,B 是 A 的子类。子类中可以继承父类的东西。

 1 /**
 2  * 父类
 3  */
 4 public class Animal {
 5 
 6     public void move(){
 7         System.out.println("move");
 8     }
 9     
10 }

  子类,非私有字段和方法可以被继承到。构造方法不能被继承。

 1 /**
 2  * 子类
 3  */
 4 public class Cat extends Animal {
 5 
 6     @Override
 7     public void move() {
 8         super.move();  //super关键字:通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
 9     }
10 }

  Java中只能是单继承,即一个类只有一个父类;但支持多重继承(多层继承),即一个类可以有子类,子类还可以子类...  子子孙孙无穷无尽...

2、方法的重写(Override)

方法重写的要求:

1、子类和父类的方法签名(方法名+方法参数列表)一致。

2、子类的访问权限不能比父类更低。

3、最好加上@Override,来让编译器检查是否重写正确。

4、私有方法和 static 方法不能被重写。

5、子类的返回值类型可以和父类相同或者是父类返回类型的子类。

 1 /**
 2  * 子类
 3  */
 4 public class Cat extends Animal {
 5     @Override
 6     public void move() {
 7         System.out.println("move on");  //重写父类方法
 8     }
 9 
10 }

5、接口

  接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

声明语法:

interface 接口名{
 // 内部可以有哪些成员--参考类
字段  全部都是全局常量(public static final修饰)
方法  全部都是抽象方法(缺省修饰public abstract)
构造方法  没有!
}

接口名一般加个大写的 I 在前面。

1 public interface IAnimal {
2     
3     void run();
4     
5     void eat();
6 }

  使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

注意:

1、必须全部覆写接口中的抽象方法。

2、否则实现类也抽象类。

3、一个类可以实现多个接口,但必须重写所有接口中的抽象方法。

 1 public class AnimalImpl implements IAnimal {
 2     @Override
 3     public void run() {
 4         System.out.println("run");
 5     }
 6 
 7     @Override
 8     public void eat() {
 9         System.out.println("eat");
10     }
11 }

6、多态

   多态是同一个行为具有多个不同表现形式或形态的能力。即同一个事件发生在不同的对象上会产生不同的结果。

多态的优点:

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

多态存在的三个必要条件

1、继承

2、重写

3、父类引用指向子类对象

 1 /**
 2  * 父类
 3  */
 4 public class Animal {
 5     public void eat() {
 6         System.out.println("吃东西");
 7     }
 8 }
 9 
10 /**
11  * 子类
12  */
13 class Cat extends Animal {
14     public void eat() {
15         System.out.println("猫吃鱼");
16     }
17 
18     public void work() {
19         System.out.println("猫抓老鼠");
20     }
21 }
22 
23 class Dog extends Animal {
24     public void eat() {
25         System.out.println("狗吃骨头");
26     }
27     public void work() {
28         System.out.println("狗看家");
29     }
30 }
31 
32 class Person extends Animal {
33     public void eat() {
34         System.out.println("人吃东西");
35     }
36     public void work() {
37         System.out.println("人努力工作");
38     }
39 }

测试多态:

 1 public class Test {
 2     public static void main(String[] args) {
 3         Animal a = new Cat();  // 向上转型
 4         a.eat();   // 调用的是 Cat 的 eat :首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
 5         Cat c = (Cat)a;  // 向下转型,强制转换
 6         c.work();    // 调用的是 Cat 的 work
 7 
 8         Animal b = new Dog();
 9         b.eat();
10         Dog d = (Dog)b;
11         d.work();
12 
13         Animal person = new Person();
14         person.eat();
15         Person p = (Person)person;
16         p.work();
17         
18         /* 输出:
19         猫吃鱼
20         猫抓老鼠
21         狗吃骨头
22         狗看家
23         人吃东西
24         人努力工作*/
25     }
26 }

多态的实现方式

1、重写

2、接口

3、抽象类和抽象方法

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:讲说问题:|和||的区别以及&和&&的区别。2、Java中

下一篇:Servlet案例5:用户登录失败信息回显