Java面向对象

Java面向对象编程

三大特性 封装 继承 多态

创建对象内存分析

定义了有参构造默认的无参构造失效

封装

getter setter （alt+insert）构造器

继承

1. extends子类继承父类的所有方法（public）
2. Java只有单继承没有多继承
3. Java中所有的类默认继承Object类

super

public class Person{
    protected String name = "kuangshen";
    
    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person{
    
    public Student(){
        super();
        //隐藏代码：调用了父类的无参构造
    }
    
    private String name = "qinjiang";
    
    public void print(){
        System.out.println("Student");
    }
    
    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name); //qinjiang
        System.out.println(super.name); //kuangshen
    }
    
    public void test2(String name){
        print(); //Student
        this.print(); //Student
        super.print(); //Person
    }
}

方法重写

都是方法的重写，和属性无关

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

public class A extends B {
    @override
    public void test(){
        System.out.println("A=>test()");
    }
}

public class Application {
    public static void main(String args[]){
        A a = new A();
        a.test(); //A=>test
        
        B b = new A();
        b.test(); //A=>test
}

1. 静态的方法调用只和左边有关
2. 非静态public子类重写了父类的方法

多态

public class Application {
    public static void main(String args[]){
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了，父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
    }
}

1. static 方法属于类，它不属于实例
2. final 常量
3. private方法

类型转换

public class Application {
    public static void main(String args[]){
        Object object = new Student();
    	System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String); //false
    }
}

父类强转成子类需要加括号

子类转成父类可以默认转换，可能会丢失自己本来的方法

static关键字

静态代码块

public class Person {
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块"); //只执行一次，用来赋初始值
    }
    public Person() {
        System.out.println("构造方法")
    }
    public static void main(String args[]) {
        Person person1 = new Person();
        System.out.println("============");
        Person person2 = new Person();
    }
}

//静态代码块
//匿名代码块
//构造方法
//============
//匿名代码块
//构造方法

新特性

静态导入包

import static java.lang.Math.random;

通过final修饰的类不能被继承

抽象类

public abstract class Action {
   //抽象方法，只有方法名字，没有方法的实现
   public abstract void doSomething();
} //不能new这个抽象类，只能靠子类实现

//继承了抽象类的子类，必须要实现抽象类的方法
public class extends Action {
    @Override
    public void doSomething() {
        
    }
}

接口（重点）

最难的是要建立起抽象思维！！！！！

接口可以多继承

public interface UserService {
    //常量 public static final
    int Age = 99;
    
    //接口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

//类实现接口 需要重写接口的方法
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {
        
    }
    @Override
    public void delete(String name) {
        
    }
    @Override
    public void update(String name) {
        
    }
    @Override
    public void query(String name) {
        
    }   
    @Override
    public void timer() {
        
    }
    
}

public interface TimeService {
    //接口中的所有定义其实都是抽象的public abstract
    void timer();
}

内部类

public class Outer {
    private int id;
    public void out() {
        System.out.println("这是外部类的方法");
    }
    
    public class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }
        public void getID() {
            System.out.println(id);
        }
    }
}

public class Application {
    
    public static void main(String[] args){
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

静态内部类

一个Java类中可以有多个class类，但是只能有一个public类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        new UserService(){
            
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    
}

局部内部类

public class Outer {
   public void method() {        
       class Inner{
           public void in() {
               
           }
       }      
   }
}