Java面向对象

静态/非静态方法

静态方法只能调用静态方法，非静态方法可以调用静态方法:

    public static void main(String[] args) {
        //静态方法 static 可以直接用类名.方法名直接调用
        //非静态方法 需要先实例化这个类 new
        Student student = new Student();
        student.say();
    }

    public static void a(){
        //b();  此时调用b会报错  因为static是和类一起加载的 b()此时还没有加载
    }
    //类实例化 之后才存在
    public void b(){
    }

值传递和引用传递

普通的函数:传进去的参数是拷贝的一份

//引用传递:对象 ,本质还是值传递
public class demo03 {
    public static void main(String[] args) {
        Person person =new Person();
        System.out.println(person.name);    //null
        demo03.change(person);
        System.out.println(person.name);    //xxx
    }

    public static void change(Person person){
        person.name = "xxx";    //因为person是一个对象  指向的--->Person person - new Person() 这是一个具体的人 可以改变属性
    }
}

class Person{
    String name;
}

构造器

• 一个类即使什么都不屑，它也会存在一个方法(构造器)

• 类中的构造器也称为构造方法，是在创建对象的时候必须调用的。并且构造器有以下两个特点:

  • 1.必须和类的名字相同

  • 2.必须先没有返回类型，也不能写void

public class Person {
    String name;

    //作用:实话初始值
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){
        //构造器
        this.name = "alingo";
    }

    //有参构造:  一旦定义了有参构造，无参就必须显式定义
    public Person(String name){
        this.name = name;
    }

    //alt + insert  自动生成构造器(根据属性来构造)

}

创建对象内存分析

public class Pet {
    public String name;
    public int age;

    public void shout(){
        System.out.println("叫了一声");
    }
}

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        Pet cat = new Pet();
    }
}

封装

高内聚，低耦合：高内聚:类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用

属性私有，get/set

• private关键字

继承

• 关键词: extends 子类(派生类)是父类的扩展

• Java类中只有单继承，没有多继承！（一个儿子只能有一个父亲，但一个父亲可以有多个儿子）

• 还有组合的关系:

  public class Student {
      Person person;
  }
  

• 子类继承了父类，就会拥有父类的全部public方法、pulic属性

//在Java类中，所有的类都默认直接或间接继承了Object类
public class Person /*extends Object*/{
    // 默认就是public
    //private
    //protected

    private int money = 10_0000_0000;


    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

• Ctrl + H可显示树状的类目录

super注意点:

• super调用父类的构造方法,必须在构造方法的第一个

• super必须只能出现在子类的方法或者构造方法中

• super和this 不能同时调用构造方法

Vs this：

• 本升调用者这个对象

• super:代表父类对象的应用

前提:

• this: 没有继承也可以使用

• siper：只能在继承条件才可以使用

构造方法:

• this();    本类的

重写

• 需要有继承关系，子类重写父类的方法

• 方法名必须相同

• 参数列表必须相同（不然就是重载了）

• 修饰符：范围可以扩大：public > Protected > Default > private

• 抛出的异常：范围，可以被缩小，但不能被扩大：

  ClassNotFoundException-->Exception(大)

为什么需要重写：

• 父类的功能，子类不一定需要，或者不一定满足

Alt + Insert: override

静态方法：

public static B{
    public static void test(){
        System.out.println("B");
    }
}

public static A extends B{
    public static void test(){
        System.out.println("A");
    }
}

A a = new A();
a.test();//输出 A

//父类的引用指向了子类
//方法的调用只和左边，定义的数据类型有关
B b = new A();
b.test();//   输出B

非静态方法：重写

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

public class A extends B{
    //Override  重写
    @Override   //注解：有功能的注释！
    public void test() {
        System.out.println("A");
    }
}

        A a = new A();       //输出的是A

        a.test();
        B b = new A();       //输出的仍然是A  因为子类重写了父类的方法  只在非静态方法中有效 因为非静态方法在创建时加载好了

        b.test();

静态的方法和非静态的方法区别很大

静态方法：方法的调用之和左边，即定义的数据类型有关

非静态：重写

多态

• 即同一方法可以根据发送对象的不同而采用不同的行为方式

• 一个对象的实际类型是确定的，但引用类型就不确定了

        Student s1 = new Student();
        //Student 能调用的方法都是自己的或者继承父类的

        //Person 父类型  可以指向子类，但是不能调用子类独有的方法
        //可以指向的引用类型不确定
        Person s2 = new Student();  //Person 是Student的父类  这里是父类的引用指向子类
        Object s3 = new Student();  //同理

//同样是Student对象，但有不同状态：多态
        
        s1.eat();
        s2.eat();

对象能执行哪些方法，主要看对象左边声明的类型，和右边关系不大！

所以子类指向的引用和父类指向的引用是不同的

• 子类 能调用的方法都是自己的或者继承父类的

• 父类型 可以指向子类，但是不能调用子类独有的方法

多态注意事项：

• 多态是方法的多态，属性没有多态

• 父类和子类，有联系 父类和子类才能进行类型转换， 否则出现类型转换异常：ClassCastException

• 存在条件：继承关系 方法需要重写， 父类引用指向引用指向子类对象 Father f1 = new Son();

• 不能重写的方法:

  • static 方法，属于类，它不属于实例

  • final 常量

  • private

instanceof 和类型转换

instance of 判断两个类之间是否有父子关系

编译，判断的是左边，即数据类型如果不满足父子关系就直接报错了

而运行出来为false是判断右边的对象

        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  String);  //false

        Person person = new Student();
        System.out.println(person instanceof Student);  //true
        System.out.println(person instanceof Person);   //true
        System.out.println(person instanceof Object);   //true
        //System.out.println(person instanceof Teacher);  //false
        //System.out.println(person instanceof String);   //编译报错

类型转换

//高                   低
Person student = new Student();   //低到高  不需要强制类型转换  子类到父类，可能丢失自己本来的一些方法

Student student = (Student) obj;    //高到低 需要强制类型转换 

总结

• 父类引用指向子类对象(不能反过来)

• 把子类转化成父类，向上转型，不需要强制类型转换

• 把父类转化为子类，向下转型，需要强制转换

static

静态变量对于类，所有对象(实例)所共享，当直接使用类去调用也说明这个变量是静态的:

public class Student {
    private static int age; //静态的变量
    private double score;   //非静态的变量

    public static void go(){

    }

    public void run(){
        go();       //非静态函数可以调用静态函数  反之则不行 因为静态是先加载的
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        //System.out.println(Student.score);    会报错 因为score不是静态变量
        System.out.println(s1.age);
        System.out.println(s1.score);

        Student.go();
        go();
        //Student.run();    会报错  非静态方法必须new出对象后再使用
    }
}

public class Person {
    //顺序2： 一般用来赋初值
    {
        System.out.println("匿名代码块");
        //代码块 （匿名代码块）  创建对象的时候创建  且在构造器函数之前
    }
    //只执行一次  顺序：1
    static{
        System.out.println("静态代码块");
        //静态代码块  和类加载的时候执行，且只执行一次
    }
    //顺序：3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();       //分别输出了 静态代码块、匿名方法块、构造方法

        Person person2 = new Person();        //只输出了匿名代码块、构造方法
    }
}

静态导入

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());  //没导入之前需要加Math.

        //通过静态导入之后就可以直接调用了
        System.out.println(random());
        System.out.println(PI);
    }
}

关键字final:

是修饰常量的关键字，修饰之后它也不能再有子类了，不能再被继承了

抽象类

用abstract关键字修饰

//abstract抽象类 ：类 extends :单继承 有局限性  （接口可以多继承）
public abstract class Action {
    //约束  让别人帮我们实现
    //abstract  抽象方法 只有方法名，没有方法的实现
    public abstract void doSomething();

    //1. 不能new 这个抽象类，只能靠子类去实现它：  约束！
    //2. 抽象类中可以写普通的方法
    //3. 抽象方法必须在抽象类中

    //存在的意义： 抽象出来 提高开发效率
}

接口

• 普通类：只有具体实现

• 抽象类：具体实现和规范(抽象方法)都有！

• 接口：只有规范！自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程~

接口就是规范，接口的本质是契约，是对对象的抽象

用interface 关键字定义

作用：

• 约束

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

• 方法:public abstract

• 属性:public static final

• 接口不能被实例化_{，接口中没有构造方法}

• implements 可以实现多个接口

• 必须要重写接口的方法~

public interface TimeService {
    void timer();
}


//interface 定于的关键字  接口都需要有实现类
public interface UserService {
    //属性默认的类型是 public static final int AGE = 99     常量
    int AGE = 99;
    //接口中的所有定义其实都是 公有 抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

内部类

• 成员内部类

    public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
}

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

    }

• 静态内部类

public class Outer {
 private int id=10;
 public void out(){
 System.out.println("这是外部类的方法");
 }
 public static class Inner{
 public void in(){
 System.out.println("这是内部类的方法");
 }
 //这时候就会报错了 拿不到private 因为public会先执行  除非属性也是static的
 public void getID(){
 System.out.println(id);
 }
 }
 }

• 局部内部类

public class Outer {

    //局部内部类  写在方法里面的类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

• 匿名内部类