面向对象3

1、代码块=普通代码块+静态代码块。

package LESSON6;

public class DEMO2 {
    int a;//实例变量
    static int b;//类变量
    //普通代码块：{}，每次创建对象之前都会执行。可以初始化类变量和实例变量
    {
        a=1;
        b=2;
        
        System.out.println("普通代码块");
    }
    //静态代码块：static{}，类加载之后先执行，且只会执行一次。只能初始化类变量。
    static{
        //a=3;报错
        b=4;
        System.out.println("静态代码块");
    }
    public DEMO2(){
        System.out.println("无参构造器");
    }
    public void test(){
        System.out.println("test方法");
    }

    
    public static void main(String[] args) {
        //执行顺序：静态代码块>>普通代码块>>构造器>>对象调用的属性以及方法
        DEMO2 demo=new DEMO2();
        DEMO2 demo2=new DEMO2();
        demo.test();//如main方法里什么都不写，则只会执行静态代码块中的内容
      

    }

}

2、类成员与实例成员

类成员：

使用static修饰的成员方法和成员变量称为类成员
使用static修饰的成员变量叫做类变量
使用static修饰的成员方法叫做类方法

实例成员：

未使用static修饰的成员方法和成员变量称为实例成员
未使用static修饰的成员变量叫做实例变量
未使用static修饰的成员方法叫做实例方法

类方法使用：类名.方法名([参数])调用
实例方法使用：对象名.方法名([参数])调用

package LESSON6;

public class DEMO1 {
    public static String name;
    public int age;
    public static void eat(){
        //静态方法里只能使用静态的变量
//        public static int eat;//

        System.out.println("吃");
    }
    public void drink() {
        System.out.println("喝");
        
    }
    public static void main(String[] args) {
        DEMO1.name="张三";
        System.out.println(name);
        DEMO1 de1=new DEMO1();
        DEMO1 de2=new DEMO1();
        de1.name="李四";
        System.out.println(name);
        de2.name="jack";
        de1.age=20;
        System.out.println(name);
        System.out.println(de1.age);
        
        DEMO1.eat();
        de1.eat();
        de1.drink();

    }

}

3、封装：把客观事物封装成抽象的类，并且类可以把自己的属性和方法只让可信的类或者对象进行操作，对不可信的类或者对象隐藏，这样的过程叫做封装。

方法一般不封装。

package LESSON6;
class user{
    public String username;
    private String password;//private,封装，私有化。只能在本类访问
    public String getPassword(){//获取私有属性的值
        return password;        
    }
    public void setPassword(String password){//修改私有属性的值
        this.password=password;
        
    }
}

public class DEMO3 {        
    public static void main(String[] args) {
        user demo=new user();
        demo.setPassword("123456");
        System.out.println(demo.getPassword());

    }

}

4、继承

一个新类可以从现有的类派生，这样的过程叫做继承。只能继承父类所有非私有的属性和方法。子类创建对象默认调用父类无参构造器。

Java中的继承是单继承，也就是一个类只能有一个父类。
如果一个类没有显式的继承某一个类，那么它有一个默认的父类是java.lang.Object类（隐式）
Java继承了父类非私有的成员变量和成员方法，但是请注意：子类是无法继承父类的构造方法的

重写和super

子类从父类继承的某个实例方法无法满足子类的功能需要时，需要在子类中对该实例方法进行重新实现，这样的过程称为重写，也叫做覆写(覆盖)。

方法重写的要求；
子类重写方法的访问修饰范围必须大于或者等于父类对应方法的访问修饰符范围
除修饰符外，重写方法的其他部分必须和父类保持一致。还有抛出的异常>=父类

super代表的是父类对象
 super的使用方式
 super.属性名 用于在子类中调用父类被隐藏的同名实例变量
 super.方法名 用于在子类中调用父类中的同名方法
 super([参数列表]) 用于在子类的构造方法中调用父类的构造方法

每一个子类的构造方法在没有显示调用super()系统都会提供一个默认的super()
 super() 书写在第一行
可以在子类构造方法中显示调用super(),完成对特定父类构造方法的调用

package LESSON6;

class Person{
    public Person(String name,int i){
        this.name=name;
        System.out.println("父类有参构造器");
    }
   public Person(){
        System.out.println("父类无参构造器");
        
    }
    public String type="不分男女";
    public String name;
    private int age;
    public void eat(){
        System.out.println("吃面");
    }
}
class Work extends Person{
    public Work(){
        super("",1);//调用父类构造器,必须要在子类构造器中调用,如不写这句话默认调用父类无参构造器,如果只定义了一个有参构造器时不写这句话会报错
        System.out.println("子类无参构造器");
        
    }
    public String type="男";
    public String name="jack";
    public int id;
    public void work(){
        System.out.println("我在工作");
        System.out.println(super.type);//调用父类属性
    }
    
    //重写(override)与父类相同的方法
    public void eat(){
        System.out.println("我只喜欢吃排骨");    
        super.eat();//调用父类方法
    }
    
    
    
}

public class DEMO4 {
    
    public static void main(String[] args) {
        Person person=new Person("rose",1);
        person.eat();
        System.out.println(person.name);
        System.out.println("\\\\\\\\\\\\\\\\\");
        
        Work work=new Work();    
        work.id=123456;
        work.eat();
        work.work();
        System.out.println(work.id+"	"+work.name);
    }

}

 5、访问修饰符