Java学习笔记之封装与继承

封装

1，将属性定义为私有的(private) 不能通过对象名.属性来直接访问，但是可以通过方法来间接的访问,

2，封装的意义:公有属性可以被随意修改，并且不能被程序察觉。封装后，别人通过方法来访问属性时，我们可以添加限制，访问可以被程序察觉。

下面我们用封装定义一个手机类（这种类一般我们称为 javabean）

 1 public class Phone {
 2     private String type;
 3     private int price;
 4     private String color;
 5      
 6     public String getType(){
 7         return type;
 8     }
 9     public void setType(String type){
10         this.type=type;
11     }
12     public int getPrice() {
13     return price;
14     }
15     public void setPrice(int price) {
16     this.price = price;
17     }
18     public String getColor() {
19     return color;
20     }
21     public void setColor(String color) {
22     this.color = color;
23     }
24      
25 }

注意

1，类中属性和方法的定义顺序没有先后之分

2，当参数与属性重名时，计算机会优先考虑参数(这本身是错误的，不要这样做)

继承

继承：子类继承父类的几乎所有内容（属性跟方法）关键字 extends

1，那么什么不能被继承呢？ private（私有属性）和构造方法不能被继承

2，所有类都是object的子类

3，在java中只能单继承

重写：当子类继承过来的方法不满意，重新覆盖这个方法。

1，当重写了父类的方法，调用的是子类重写过的方法，不会调用父类的那个方法。

1 public class Person {
2      
3      public void eat(){
4          System.out.println("我是父类的方法吃...");
5      }    
6 }

1 public class Student extends Person {
2     //重写  方法名与父类相同 会覆盖父类的方法
3     @Override
4     public void eat() {
5         System.out.println("我是子类中重写的父类方法吃...");
6     }
7 }

1 public class Text {
2     //我是测试类
3     public static void main(String[] args) {
4            Student s=new Student();
5            s.eat();
6     }
7 }
8 //控制台输出结果为：
9 //我是子类中重写的父类方法吃...

2，super 可以在子类中调用父类的方法

 1 public class Student extends Person {
 2      //重写  方法名与父类相同 会覆盖父类的方法
 3     @Override
 4      public void eat() {
 5          //调用父类中的eat()
 6          super.eat()
 7          System.out.println("我是子类中重写的父类方法吃...");
 8      }
 9 }
10 //若再进行测试，控制台输出结果为：
11 //我是父类的方法吃...
12 //我是子类中重写的父类方法吃...

重载：方法名与父类相同，参数列表不同，是根据参数列表来匹配执行哪个方法

 1 public class Student extends Person {
 2      //重载  方法名与父类相同，参数列表不同
 3      public void eat(String s) {
 4          System.out.println("我是子类中重载的父类方法吃...");
 5      }
 6 }
 7 
 8 
 9 public class Text {
10         //我是测试类
11     public static void main(String[] args) {
12            Student s=new Student();
13            //参数对应就会调用相应的方法
14            s.eat("sss");
15         }
16 }
17 //结果为：我是子类中重载的父类方法吃...

要点：当创建子类对象的时候，会先初始化父类的对象。如果没有显示调用父类的构造方法，默认调用父类的无参的构造方法。

构造方法重载

 1 public Student(String sex){
 2         System.out.println("------>sex");
 3         //如果没有显示调用父类的构造方法，默认调用父类的无参的构造方法。
 4         this.sex = sex ;
 5 }
 6     
 7 public Student(String sex,int age){
 8         this(sex); // this() 表示的是本类其他的构造方法，根据参数寻找是哪个构造方法。当表示其他构造方法的时候必须必须放在第一行。
 9         this.age = age ;
10         System.out.println("------>sex age ");
11 }
12     
13     
14 public Student(){
15         super("sssss");// 显示调用父类的构造方法，不需要方法名。当super父类构造方法的时候，必须放在第一行。
16         System.out.println("-----Student的构造方法------");
17 }

Java学习笔记之封装与继承

相关推荐