Java面向对象——Java的三大特性

封装：

• 什么是封装：

　　　　将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

• 如何实现封装: 

1. 修改属性的可见性，设为private。
2. 建立共有的get/set方法，用于属性读写。
3. 在get/set方法中加入属性的控制语句，对属性的合法值进行判断

1. 便于使用者正确使用系统，防止错误修改属性
2. 有助于系统之间的松耦合，提高系统独立性
3. 提高软件的可重用性
4. 降低了构建大型系统的风险

创建封装类
class Person {
    private String name ; //属性必须被private修饰
    public String getName() {    //公有get方法
        return name;             //控制语句        
    }
    public void setName(String name) {//公有set方法
        this.name = name;          //控制语句   
   }
   public void out（）{
   System.out.println("我的名字是:"+name);
    }
   }
}
//可以使用 alt+shift+s 键然后按R键快速设置get/set方法

测试代码块
public class Test {
    public static void main(String[] args) {
            Person p=new Person();
            png.setName(name);
            //Person p=new Person(name);  //可以使用有参构造方法创建对象
            // 输出信息
            p.out();
    }
}

Static修饰符

　　Staric的五种用法

1. 1. 修饰静态属性；
   2. 修饰静态方法；
   3. 修饰静态内部类；
   4. 静态导包（类或者方法，可以通配）；
   5. 标记静态代码块

Static修饰的类和属性可以被类名直接调用： 类名.属性名 类名.方法名

Static 用法实例
import static java.lang.System.out;//静态导包，静态导包的好处就是可以直接使用对象或者方法，不用再依赖于对象对象或者类来调用

public class Person {
    static double num=2;//静态变量
    
    static void out(String string){ //静态方法
           out.println(string);//静态导包可以直接使用对象或者方法，不用再依赖于对象对象或者类来调用
       }
    static class NewPerson {   //静态类
        public String show() {
            return("静态内部类实例 ");
        }
    }
    
   static{ //静态代码块 最优先的 当Java虚拟机加载类时，就会执行该代码块
          System.out.println("静态代码块实例1");  
       }
    static{ //静态代码块
          System.out.println("静态代码块实例2");  
       }
    static{ //静态代码块
          System.out.println("静态代码块实例3");  
       }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Person.out("静态方法实例");
        
    }

}

Static与非Static的区别：

1. static修饰的成员是随着类的加载而加载(优先)
2. 非static成员是随着对象的创建而加载
3. 静态方法|静态代码块只能调用静态成员，非静态成员是不能直接调用的，创建对象(不能使用this，super 关键字)
4. 非静态方法可以直接调用非静态成员，也可以调用静态成员.类的对象进行调用静态成员
5. 静态成员对于多个对象而言是共享的
6. 非静态成员对于多个对象是彼此独立的
7. 静态方法和静态变量创建后始终使用同一块内存,而使用实例的方式会创建多个内存

 继承:

• 类和类之间的关系

在Java所有类都默认继承自Object

class child extends Parent extends关键字实现类的继承

单根性:一个类只能存在一个父类

在Java中的继承:子类可以继承父类的任何非私有成员(变量 方法 构造) 子类永远比父类拥有更多的成员 子>父

提升代码的复用性:

减少代码的冗余

子类继承父类public和protected修饰的属性和方法，不能继承private成员和构造方法。

• 子类访问父类成员构造方法：

1. 1. 使用super关键字，super代表父类对象
   2. 在子类构造方法中，调用且必须是第一句
   3. 不可以访问父类中定义为private的属性和方法

访问构造方法：super();||super(name);

访问父类属性：super.name;

访问父类方法：super.print();

注：super和this的区别，this指当前对象，super指父类对象，super一般只存在于有继承关系的类中。

• 抽象类: abstract关键字修饰的类

 不能直接实例化
 内部可以存在抽象方法:

1.  抽象类和抽象方法使用abstract关键字修饰
2. 抽象方法不能存在方法体，可以设置返回类型
3. 抽象类中的抽象方法子类必须重写，除非子类也是抽象类
4. 抽象类中既能存在抽象方法，又能存在非抽象方法，也可以构造函数

//抽象类
 2 public abstract class Clothes {
 3     String quality;//衣服材质
 4     
 5     //普通方法
 6     public void cross(){
 7         System.out.print("衣服都可以穿！");
 8     }
 9     //抽象方法
10     public abstract void type();//衣服类型
11     
12     //构造方法
13     public void Clothes(){
14         
15     }
16     public void Clothes(String s){
17         
18     }
19 
20 }

public class Skirt extends Clothes{
2 
3     //抽象方法子类中必须重写
4     @Override
5     public void type() {
6         System.out.print("我是一件裙子！");
7         
8     }

1. 类型转换: 向上转型: 子类向父类转换 自动转换
2.  向下转型: 父类向子类转换 强制 ClassCastException instanceof （在调用子类特有的成员时）

 1 public class Test {
 2     public static void main(String[] args){        
 3         Clothes c=new Skirt();
 4         Clothes c1=new Clothes();
 5         Skirt s=new Skirt();
 6         if(c1 instanceof Skirt){
 7             //父类向子类转换时，会抛出classcastException异常
 8              s=(Skirt) c1;            
 9         }else{
10             s.price();
11         }
12         //子类向父类转换时，会自动转换
13         c1=s;
14         c.type();        
15     }    
16 }

子类可以再任何时刻替代父类: is a关系

多态：

同一引用类型，使用不同的实例而执行不同操作（）

• 方法的重写是实现多态的基础。

1 public  class Clothes {
2     String quality;//布料
3         
4     public void type(){
5         System.out.print("我是衣服！");
6     }

1 public class Skirt extends Clothes{    
2     String pinp;//品牌
3     //重写父类方法
4     @Override
5     public void type() {
6         System.out.println("我是一件裙子！");        
7     }    

• 使用父类作为方法的形参，是Java中实现和使用多态的主要方式。

创建父类方法

 1 public  class Clothes {
 2     String quality;//布料
 3         
 4     public void type(){
 5         System.out.print("我是衣服！");
 6     }
 7     
 8     //制作方式
 9     public void made(){};
10 }

创建两个子类

1 public class Skirt extends Clothes{    
 2     String pinp;//品牌
 3     
 4     @Override
 5     public void type() {
 6         System.out.println("我是一件裙子！");        
 7     }    
 8     //重写父类方法
 9     public void made(){
10         System.out.print("我是裙子，由工厂制作出来的！");
11     }
12 
13 }

重写父类方法

1 public class TShirt extends Clothes{
2     
3     //重写父类方法
4     public void made(){
5         System.out.print("我是T恤，由私人定制的！");
6     }
7 
8 }

创建形参是父类的方法

 

1 public class Service {
2     
3     //创建父类形参方法
4     public void made(Clothes cs){
5         cs.made();
6     }
7 
8 }

 

 

创建测试类

 1 public class TestCase {
 2         
 3     public static void main(String[] args){
 4         //创建Service对象
 5         Service se=new Service();    
 6         //通过父类将对象指向子类
 7         Clothes t=new TShirt();
 8         //调用方法
 9         se.made(t);
10     }
11 
12 }

• 使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式。

 1 //父类作为方法的返回值
 2     public Clothes getID(int num){
 3         Clothes cl=null;
 4         if(num==1){
 5             cl=new Skirt();
 6             cl.made();
 7         }
 8         else if(num==2){
 9             cl=new TShirt();
10             cl.made();
11         }
12         return cl;
13         
14     }