3.面向对象(传智播客)

一.简介
1.面向过程和面向对象

• 面向过程：解决问题时关注动作，将动作用函数封装起来，然后再一一调用。
• 面向对象：解决问题时关注对象，因为对象包含了特征和功能，找到对象即找到了功能。

2.类
类是用来描述对象的，是对对象共性内容的抽象。

3.对象
世界万物皆对象，对象是包含属性和方法的实例。
如：小明 男 21岁 吃饭 打篮球
小红 女 20岁 吃饭 跳舞

4.类和对象的关系
类是用来描述对象，对象是类的一个实例。

5.实例化(构造函数)
当对象一创建时，就需要用构造函数给对象的属性进行初始化，每创建一个对象，在内存中就创建一个实例。当没有属性需要初始化时，则不需要显示创建构造函数，系统会创建一个什么也不做的默认构造函数，顺利完成初始化。

public class A {
    public A() {
        System.out.println("A");
    }
}

public class B extends A{
    public B() {
        System.out.println("B");
    }
}

//A
//B

6.局部变量和成员变量的区别

• 成员变量定义在类中，整个类中都可以访问。 局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
• 成员变量存在于堆内存的对象中。 局部变量存在于栈内存的方法中。
• 成员变量随着对象的创建而存在，随着对象的消失而消失。 局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
• 成员变量都有默认初始化值。 局部变量没有默认初始化值。

二.封装
1.介绍
每个对象都包含了它能进行操作所需要的所有内容并向外提供访问的接口，称之为封装。封装的好处有：

• 减少耦合
• 具有清晰的对外接口
• 可自由修改内部内容而不影响其它类

2.构造函数
用来给对象进行初始化的方法。特点如下：

• 与类名相同
• 没有返回值
• 没有返回值类型
• 不继承不覆盖

3.this
哪一个对象调用了包含this的方法，那么this就指向哪一个对象。
this的作用：

• 在方法中区分同名变量
• 在构造函数中调用同类的构造函数

public class Basic {
   private String str;

   public Basic() {
       //出现在第一行
       this("hello");
       System.out.println("basic");
   }

   public Basic(String str) {
       this.str = str;
       System.out.println(str);
   }

   public static void main(String[] args) {
           new Basic();
   }
}

4.static

• 静态变量(如果类中一个变量的值始终不变，就可以用static来修饰，是为类所有，不是对象所有)
• 静态方法(函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据)

只能调用静态成员
不能使用this或者super

• 静态代码块(随着类的加载而加载，只加载一次)

初始化顺序：详细参照Java类初始化顺序说明

三.继承
1.介绍
在一个类的基础上构造一个新类，在不改变原来类的基础上扩展新功能。

2.继承形式

• 单继承
• 多继承(java为什么没有)
• 多重继承

3.super

• 调用父类的成员
• 在子类的构造方法中调用父类的构造方法

只能出现代码的第一行

4.final

• 修饰变量(不管成员变量还是局部变量都需要进行初始化，因为他们的值是不可变化的，如果没有初始化就没有意义了)
• 修饰方法(不可覆盖)
• 修饰类(不可继承)

5.继承的内容

public class Fu {
    public  String str = "fu";

    public Fu() {
        System.out.println("fu construct......");
    }

    public  void fun(){
        System.out.println("fu fun......");
    }
}

public class Zi extends Fu{
    
}

public class Basic {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.str);
        zi.fun();
    }
}

子类不覆盖父类的成员，就只会调用父类的成员。

public class Fu {
    public  String str = "fu";

    public Fu() {
        System.out.println("fu construct......");
    }

    public  void fun(){
        System.out.println("fu fun......");
    }
}

public class Zi extends Fu{
    public  String str = "zi";

    public Zi() {
        System.out.println("zi construct......");
    }

    public  void fun(){
        System.out.println("zi fun......");
    }
}

public class Basic {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.str);
        zi.fun();
    }
}

如果子类覆盖父类的成员，则优先调用子类的成员。

四.多态
1.简介
允许用父类类型的引用指向子类对象。

• 让方法具有通用型
• 让相同的底层数据接口具有不同表现形态

2.转型

• 向上转型(自动转换，但是引用变量无法访问子类特有内容)
• 向下转型(强制转换)

3.实现形式

public abstract class Animal {
   abstract void shout();

   abstract  void eat();
}

public class Dog extends Animal {
    @Override
    void shout() {
        System.out.println("汪汪......");
    }

    @Override
    void eat() {
        System.out.println("啃骨头......");
    }
}

public class Cat extends Animal{
    @Override
    void shout() {
        System.out.println("喵喵......");
    }

    @Override
    void eat() {
        System.out.println("吃鱼......");
    }
}

public class Basic {
    public void fun(Animal animal){
        animal.shout();
        animal.eat();
    }
    public static void main(String[] args) {
        Basic basic = new Basic();
        basic.fun(new Dog());
        basic.fun(new Cat());
    }
}

4.经典面试题

class F{
    String s = "father";
    public void run(){
        System.out.println("father run...");
    }
    public void dance(){
        System.out.println("father dance...");
    }
}
class S extends F{
    String s = "son";
    public void run(){
        System.out.println("son run...");
    }
    public void sing(){
        System.out.println("son sing...");
    }
}
public class Test{
    public static void main(String[] args) {
        F s = new S();
        System.out.println(s.s);//father
        s.run();//son run...
        // s.sing();

        S s1 = new S();
        System.out.println(s1.s);//son
        s1.run();//son run...
        s1.sing();//son sing...

        F f = new F();
        System.out.println(f.s);//father
        f.run();//father run...
        f.dance();//father dance...
    }
}

class F{
    String s = "father";
    public void fun(){
        System.out.println("father run...");
    }
    public static void fstatic(){
        System.out.println("father static func...");
    }
}
class S extends F{
    String s = "son";
    public void fun(){
        System.out.println("son run...");
    }
    public static void fstatic(){
        System.out.println("son static func...");
    }
}
public class Test{
    public static void main(String[] args) {
        F s = new S();
        System.out.println(s.s);//father
        s.fun();//son run...
        s.fstatic();//son static func...
    }
}

五.抽象类
1.简介
java允许在定义类的时候不写方法的方法体，这些方法叫做抽象方法，含有抽象方法的类叫做抽象类。抽象类和抽象方法都有关键字abstract修饰。

2.特点

• 不能被实例化，只有实现该类的所有抽象方法的类才可以实例化，否则子类仍然是抽象类
• 不一定含有抽象方法，可以含成员变量和方法

六.接口
1.简介
如果一个抽象类的所有方法都是抽象方法，那个这个抽象类就可以用接口来定义。

2.特点

• 不能被实例化，只有实现该接口的所有抽象方法的类才可以实例化，否则子类仍然是抽象类
• 一个接口是只含有成员变量和抽象方法的特殊类
• 有固定的修饰符
  • 类 public interface
  • 成员变量 public static final
  • 抽象方法 public abstract
• 可以多继承以及多实现
  • 一个接口继承多个接口哦
  • 一个类实现多个接口
  • 一个类继承一个类实现多个接口

七.访问修饰符

八.包
1.简介
包是用来管理java类文件的

2.定义与使用

package packageName;

import packageName.className;