Java核心之面向对象编程

本质

以类的方式组织代码，以对象组织封装数据

回顾方法调用

static

静态方法

含有static 是和类一起加载的

//demo01
public class demo01 {
    public static void main(String[] args) {
        student.say();//直接调用
        
    }
}

//student
public class student {
   public static void say(){
       System.out.println("学生说话了");
   }
}

非静态方法

类实例化之后才存在

//        实例化这个类 new
//        对象类型 对象名字=对象值；
        student stu=new student();
        stu.say();

对比

public static void a(){
        b();//无法调用 因为b未实例化 此时不存在
    }
    public  void  b(){
        System.out.println("调用b方法");
    }

引用传参

public class demo01 {
    public static void main(String[] args) {
        person per=new person();//实例化类
        System.out.println(per.name);
        change(per);//此处对象仍然是值传参
        System.out.println(per.name);
    }
    public static void change(person per){
        per.name="琴江";
    }
    
}
class person{
    String name;
    int age;
}

方法重载

方法重载：多个方法名称相同，但是形参列表不同

对象

类与对象的创建

public class demo01 {
    public static void main(String[] args) {
        person per=new person();//实例化类
        System.out.println(per.name);
        change(per);//此处对象仍然是值传参
        System.out.println(per.name);
    }
    public static void change(person per){
        per.name="琴江";
    }
    
}
class person{
    String name;
    int age;
}

构造器

一个类即使什么都不写，也会存在一个方法

作用：

1、使用new关键字，本质是调用构造器

2、用来初始化对象的值

注意：

1、定义了有参构造，如果想使用无参构造，必须显示定义一个无参构造

快捷键生成构造器：

Alt+insert

创建对象内存分析

三大特性

封装

“高内聚，低耦合”

private ：私有

private String name;
private int id;
private String sex;

get 获取数据

public String getName() {
    return name;
}

set 给数据赋值

public void setName(String name) {
    this.name = name;
}

快捷键：Alt+insert

继承

1、本质：对某一批类的抽象，从而更好建模

2、Java中类只有单继承，没有多继承；

3、继承是类和类之间的关系

4、子类用extends继承父类，子类可以调用父类中的方法、属性

public class student extends Person{}

5、Java中所有的类都会间接或直接继承object

public class student extends Object{}

6、父类的私有属性无法被继承

Super

1、super调用父类的构造方法，必须放在构造方法的第一个；

2、super必须只能出现在子类的方法或构造方法中；

3、super和this不能同时使用；

4、如果父类中只有有参构造，子类也无法调用父类的无参构造，此时super();无法调用，但是super(123)；可调用父类有参构造；

this和super的区别

1.代表对象不同：

this：本是调用者这个对象

super：代表父类对象应用

2.前提：

this：没有继承也可以使用

super：只在继承条件下使用

3.构造方法：

this();本类构造

super();父类构造

方法重写

1、方法名相同

2、参数列表必须相同

3、修饰符：范围可以扩大 public>protected>default>private

4、抛出一场 范围可以被缩写，但不能扩大

快捷键：Alt+insert：override；

多态

public class duoTai {
    public static void main(String[] args) {
        Person s1=new Student();//父类的引用指向子类
        Student s2=new Student();

        s1.run();//son 执行了方法重写
        s2.run();//son

//      s1.eat(); 无法执行，因为实例对象能实行什么方法跟左边的对象类型有关，与右边的关系不大
        ((Student)s1).eat();//强制类型转换之后可以执行
        s2.eat();
    }
}

public  class Person {
    public void run(){
        System.out.println("father");
    }

}

public class Student extends Person{

    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
 System.out.println("eat");
    }
}

注意事项：

1、多态是方法的多态，属性没有多态

2，存在条件：继承关系；方法需要重写，父类引用指向子类重写

3、static，final，private等定义修饰的不能重写

类型转换（instanceof）

高转低：强制转换

低转高：不用强制转换 可能会丢失精度

子类转父类，可能会丢失一些方法

 ((Student)s1).eat();//父类转子类，强制类型转换

static关键词

public class person {
    {//2 可用于赋值
        System.out.println("匿名代码块");
    }
    static {//1 只执行一次
        System.out.println("静态代码块");
    }

    public static void main(String[] args) {//3
        person per1=new person();
        System.out.println("============");
        person per2=new person();

    }

}

静态引入包

import static java.lang.Math.random;

System.out.println(random());//调用

抽象类

1.不能new这个抽象类，只能用子类去实现，是一个约束的存在

2.抽象类中可以写普通方法

3.抽象可用于提高开发效率

4.抽象类是抽象的抽象

接口

1.约束

2.定义一些方法，让不同的人实现

3.接口不能被实例化，接口也没有构造方法

4.implements可以实现多个接口

5.必须重写接口中的方法

步骤：

1、创建interface

2、在interface定义方法

public interface UserServer {
     int age=100;
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

2、在类中用implements接口并重写方法

public class UserServerImpl implements UserServer,TimeServer{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

内部类

内部类可访问私有属性

public static void main(String[] args) {
    outer app=new outer();
    outer.inner Inner=app.new inner();
    Inner.inner();
}

public class outer {
    private int a=100;//私有属性
    public void outer(){
        System.out.println("这是外部类方法");
    }
    public class inner{
        public void inner(){
            System.out.println("这是内部类方法");

            System.out.println(a);//访问私有属性
        }

    }


}
args) {
    outer app=new outer();
    outer.inner Inner=app.new inner();
    Inner.inner();
}

public class outer {
    private int a=100;//私有属性
    public void outer(){
        System.out.println("这是外部类方法");
    }
    public class inner{
        public void inner(){
            System.out.println("这是内部类方法");

            System.out.println(a);//访问私有属性
        }

    }


}