狂神说Java学习笔记——面向对象

面向对象

static

static 方法调用非静态方法是会报错

原因：static是跟类同时加载的，时间线很高，当调用还未加载的非静态方法时就会报错。

public class StaticTest {
    public static void main(String[] args) {

    }

    public static void a(){
//        b();//报错
        new StaticTest().b();
    }

    public void b(){

    }
}

Java的值传递和引用传递

//值传递
public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//a = 1

        change(a);

        System.out.println(a);//a = 1

    }

    /**
     * 值传递
     * @param a
     */
    private static void change(int a) {
        a = 10;
    }
}

//引用传递
public class Demo03 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        change(person);
        System.out.println(person.name);//王睿
    }

    private static void change(Person person) {
        person.name = "王睿";
    }
}

class Person{
    String name;
}

构造器（构造函数）

作用：

• 实例化初始化
• 使用new关键字，本质是在调用构造器
• 一旦定义了有参构造，无参构造就必须显式定义

public class Person{
    
    //一个类及时什么都不写，它也会存在一个方法
    //显式地定义构造器
    String name;
    
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){
        
    }
    
    //有参构造：一旦定义了有参构造，无参就必须显式定义
    public Person(String name){
        this.name = name;
    }
    
}

封装（属性私有）

作用：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加

继承

super

注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

VS this:

​ 代表的对象不同：

​ this：本身调用这个对象

​ super：代表父类对象的应用

​ 前提

​ this：没有继承也可以使用

​ super：只能在继承条件下才可以使用

​ 构造方法

​ this：本类的构造

​ super：父类的构造

重写

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

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大public>protected>default>private
4. 抛出的异常：范围，可以被缩小，但不能被扩大

重写，子类的方法和父类必须一致，方法体不同。

为什么需要重写：

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

2. Alt+Insert：override；

多态

什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力

多态就是同一个借口，使用不同的实例而执行不同操作

多态举例

public class Test{
    public static void main(String[] args){
        show(new Cat());//以Cat对象调用show方法
        show(new Dog());//以Dog对象调用show方法
        
        Animal a = new Cat();	//向上转型
        a.eat();				//调用的是Cat的eat
        Cat c = (Cat)a;			//向下转型
        c.work();				//调用的是Cat的work
    }
    
    public static void show(Animal a){
        a.eat();
        //类型判断
        if(a instanceof Cat){
            Cat c = (Cat)a;
            c.work();
        }else if(a instanceof Dog){
            Dog d = (Dog)a;
            d.work();
        }
    }
}

abstract class Animal{
    abstract void eat();
}

class Cat extends Animal{
    public void eat() {
        System.out.println("Eat Fish");
    }
    public void work(){
        System.out.println("Catch mouse");
    }
}

class Dog extends Animal{
    public void eat() {
        System.out.println("Eat Bone");
    }
    public void work(){
        System.out.println("Looking for the House");
    }
}

多态性的具体表现

比如Windows电脑中按下F1键这个动作：

• 如果在Flash界面下弹出的就是AS 3的帮助文档；
• 如果当前在Word下弹出的就是Word帮助
• 在Windows下弹出的就是Windows的帮助和支持

注意事项：

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

2. 父类和子类，有联系 类型转换异常

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

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

   final 常量

   private方法

//父类
public class Father{
    public void run{
        System.out.println("Father Run");
    }
}

//子类
public class Son extends Father{
    @Override
    public void run{
        System.out.println("Son Run");
    }
    
    public void eat{
        System.out.println("Son Eat");
    }
}


//测试类
public class Test{
    public static void main(String[] args){
        //对象能执行哪些方法，主要看左边的类型，和右边的关系不大
        Son son = new Son();//Son 可以执行Son本身和从Father那里继承的方法
        Father fa = new Son();//Father可以执行本身的方法，但是不能执行子类特有的方法
        
        son.run();//输出：Son Run
        fa.run();//输出：Son Run,子类重写父类的方法，则执行子类的方法
        
        son.eat();//输出：Son Eat
//      fa.eat();//报错，原因：父类不可以调用子类独有的方法
        ((Son)fa).eat();//进行类型转换之后，输出：Son Eat
    }
}

/**
* 1.子类能调用的方法是都是自己的或者继承父类的
* 2.父类能调用的方法是自己的 ，不能调用子类独有的方法
* 3.如果子类对父类的方法进行重写，则执行子类的方法
*/

父类引用指向子类的对象
Person person = new Student();
把子类转换为父类，向上转型
把父类转化为子类，向下转型，强制转型
方便方法的调用，减少重复代码，简洁

抽象：封装、继承、多态

抽象类

public abstract class Action {
    //抽象方法，只有名字，没有实现
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类去实现它：约束
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
}

public class A extends Action{
    @Override
    public void doSomething() {
         
    }
}

接口

public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

内部类

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

    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();
    }
}