Java学习笔记（二）封装，继承，多态

099

类和对象，

类是对象的数据类型，也是相同属性和行为的一组对象的集合

对象的属性n：对象的特征和属性

对象的行为v：

100

类的定义：类是Java程序基本组成单位

类是：对现实生活中有相同属性和行为的事务的抽象，确定对象将会有属性和行为

类=属性+行为

属性：类中通过成员变量来体现

行为：在类中通过成员方法体现

如何定义类：

public class 类名{

成员变量

成员方法

}

public class Phone{
    String brand;
    int price;
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短息");
    }
}

101

创建对象：类名 对象名 = new 类名（）；

适用对象：对象名.变量名

		对象名.方法名()

102

package com.SUM;

public class Test102 {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.name+","+s.age);
        s.name="林青霞";
        s.age=20;
        System.out.println(s.name+","+s.age);
        s.study();
        s.doHomework();
    }
}

package com.SUM;

public class Student {
    String name;
    int age;
    public void study(){
        System.out.println("好好学习天天向上");
    }
    public void doHomework(){
        System.out.println("键盘敲烂，月薪过万");
    }
}

103

栈内存（方法）

堆内存（数据）

105

多个对象指向相同

package com.SUM;

public class Test102 {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.name = "林青霞";
        s1.age = 20;
        System.out.println(s1.name + "," + s1.age);


        Student s2 = s1;
        s2.name="张曼玉";
        s2.age=30;
        System.out.println(s1.name+","+s1.age);
        System.out.println(s2.name+","+s2.age);
    }
}

106成员变量和局部变量

package com.SUM;

public class Student {
    String name;//成员变量：类中，方法外的变量
    int age;//
    public void study(){//
        int a=0;//局部变量：方法中的变量或者方法形参变量
        System.out.println("好好学习天天向上");
    }
    public void doHomework(){//
        System.out.println("键盘敲烂，月薪过万");
    }
}

成员变量和局部变量的区别:

成员变量：类中，方法外，在堆内存中，随着对象存在而存在，有初始化默认值

局部变量：方法内或者方法形参变量，栈内存，随着方法调用而存在，没默认会初始化值，先定义赋值才能使用

107

封装

private关键字（外界直接访问成员变量存在安全隐患）

private是一个权限修饰符，可以修饰成员变量和成员方法

可以保护成员不被别的类使用，被private修饰的成员只在本类中才能使用

private修饰的成员变量，如果需要被其他类使用，；

get变量名()方法用于获取成员变量的值，方法用public修饰

set变量名(参数)用于设置成员变量的值，方法用public修饰

package com.SUM;

public class Student {
    String name;//成员变量：类中，方法外的变量
    int age;//
    public void study(){//
        int a=0;//局部变量：方法中的变量
        System.out.println("好好学习天天向上");
    }
    public void doHomework(){//
        System.out.println("键盘敲烂，月薪过万");
    }
}

package com.SUM;

public class Student {
    String name;//成员变量：类中，方法外的变量
    //int age;//
    private int age;

    public void setAge(int a){
        //
        // age=a;
        if(a<0 ||a>120){
            System.out.println("您给的年龄有误");
        }else{
            age=a;
        }
    }

    public int getAge(){
        return age;
    }

private保护数据合理，保证访问权限

108

package com.SUM;

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

        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);

        s.show();
        System.out.println(s.getName()+","+s.getAge());
    }
}

package com.SUM;

public class Student {
    private String name;//成员变量：类中，方法外的变量
    //int age;//
    private int age;

    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        //
        // age=a;
        if (a < 0 || a > 120) {
            System.out.println("您给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }


    public void show() {
        System.out.println(name + "," + age);
    }

}

109

this关键字

this.成员变量

在局部变量和成员变量同名时使用this

package com.SUM;

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

        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);

        s.show();
        System.out.println(s.getName()+","+s.getAge());
    }
}

package com.SUM;

public class Student {
    private String name;//成员变量：类中，方法外的变量
    //int age;//
    private int age;

//    public void setName(String n) {
//        name = n;
//    }
    public void setName(String name){
        //name=name;//name是局部变量
        this.name=name;//this成员变量
    }

    public String getName() {
        return name;
    }

//    public void setAge(int a) {
//         age = a;
//
//    }
    public void setAge(int age){
        this.age=age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }

}

111

封装原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的getXXX(),setXX()方法

封装优势：通过方法控制成员变量的操作，提高代码安全性，把代码用方法进行封装，提高代码复用性，

112

构造方法是一种特殊的方法

构造方法是用来创建对象的、

public class Student(){

public Student(){

	//构造方法内容

}

}

package com.SUM;

public class Test102 {
    public static void main(String[] args) {
        Student s= new Student();
        s.show();

    }
}

package com.SUM;

public class Student {
    private String name;
    private int age;


    //构造方法
    public Student(){
        System.out.println("无参构造方法");
    }

    public void show(){
        System.out.println(name+"，"+age);
    }


}

并没有调用无参构造方法，但是该方法执行

方法的重载（overload）

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

a. 参数的类型不同，对应调用的方法不同

b. 此时区分方法的不在依靠方法名，依靠的是参数的数据类型（实参）

方法重载的规则：

在同一个类中

方法名相同

参数列表不同（ 数量不同 、类型不同 、顺序不同 等）

方法重载和什么有关，和什么无关？

a. 方法重载和方法名+参数列表有关

b. 方法重载和返回值类型无关

c. 方法重载和修饰符列表无关

实现理论：

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，已选择对应的方法，如果匹配失败，则编译器报错。

113

无参构造方法注意事项：

当一个类中没有构造方法，系统将会给出一个默认构造方法

一旦给出构造方法（有参数）系统将不再给出默认构造方法，如果要使用new对象就手动给出。

114

标准类制作

成员变量使用private修饰

提供一个无参构造方法，一个带多个参数的构造方法

提供一个成员变量对应setXXX（），getXXX（）

提供一个现实对象信息show()

创建对象并为成员变量赋值的两种方式：

1无参构造方法创建对象后setXXX（）赋值

2使用带参数构造方法直接创建带有属性值的对象

package com.SUM;

public class Test102 {
    public static void main(String[] args) {
        Student s1= new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        Student s2=new Student("林青霞",30);
        s2.show();
    }
}

package com.SUM;

public class Student {
    private String name;
    private int age;


    //构造方法
    public Student(){

    }
    public Student(String name,int age){

        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return  name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }




    public void show(){

        System.out.println(name+"，"+age);
    }


}

Student类和无参构造方法关系：Student类自带同名无参构造方法，new 一个对象使用的是无参构造方法，如果该方法有参数就需要在new时直接赋值

115

API（application programming interface）应用程序编程接口

api就是jdk提供各种功能Java类

116

导包

创建对象

输出对象

117

String字符串不可变，创建后不能被改变，虽然String值不可改变，但是可以共享，字符串效果上相当于char[],但是底层原理是byte[]

118

""方式给出的字符串，只要字符序列相同（序列，大小写）无论程序代码中出现几次JVM都只会建立一个String 对象，并在字符串池中维护。

120

==

基本类型，比较的是数据值是否相同

引用类型，比较的是地址值是否相同

134

ArrayList基础

集合类的特点：存储一种空间可变的存储模型，存储的 数据容量可以改变

ArrayList:可以调整大小的数组，是一种特殊数据类型，泛型

可以用引用数据类型替换：ArrayList

139

学生管理系统

功能：添加学生，删除学生，修改学生，查看所有学生，退出

实现过程：

1定义学生类

2主界面的代码编写

3添加学生代码编写

4查看学生代码编写

5删除学生代码编写

6修改学生代码编写

1：学生类Student

成员变量：学号sid,姓名name,年龄age,居住地address

构造方法：无参构造，带四个参数的构造

成员方法：每个成员变量对应给出setget方法

主界面代码编写；

1输出语句完成主界面编写

2Scanner实现键盘录入数据

3Switch完成操作选择

4循环回到主界面

添加学生代码编写

1用键盘录入选择添加学生

2定义一个方法，添加学生

		现实提示信息，提示要输入什么信息

		键盘录入学生对象需要的数据

		创建学生对象，把键盘录入数据赋值给学生对象的成员变量

		将学生对象添加到集合中保存

		给出添加成功提示信息

3调用方法

查看学生代码编写

1键盘录入选择查看所有学生信息

2定义一个方法，用于查看学生信息

	判定集合是否有数据，如果没有显示提示信息

	现实表头信息

	将集合中数据取出来按照对应格式现实学生信息，年龄补充”岁“

3调用方法

删除学生的代码编写

键盘录入选择删除学生信息

定义一个方法用于删除学生信息

	现实提示信息

	键盘录入要删除的学生学号

	键盘集合将对应的学生对象从集合中删除

	给出删除成功提示

调用方法

修改学生代码编写

1键盘录入选择修改的学生信息

2定义一个方法，用于修改学生信息

	现实提示信息

	键盘录入要修改的学生学号

	键盘录入要修改的学生信息

	遍历集合修改对应学生信息

	给出修改成功提示

调用方法

学号重复问题

1定义一个方法，对学号是否使用进行 判断：如果与集合中某一个学号相同，返回true，否则返回false

2在添加学生录入学号后调用方法，如果返回true,重新输入学号

如果返回false正常添加学生对象

006

继承中成员方法访问特点：

通过子类对象访问一个方法

子类成员范围找

父类成员范围找

找不到就报错（不考虑父亲的父亲）

007

super内存图

008

方法重写：子类中出现和父类一模一样的方法声明

方法重写应用：当子类需要父类功能，而功能主体子类有自己特有的内容，可以重写父类方法，这样沿袭了父类功能，定义了子类功能

@Override 是一个注解，可以帮助我们检查重写的方法声明的正确性

009

方法重写注意事项

父类中私有方法，子类不可能重写

子类重写父类方法，权限大于等于父类方法权限，子类方法访权限不能更低

public>默认>私有权限

010java继承注意事项

类支持单继承 ，不支持多继承（不可以继承多个类）

Java支持多层继承

011

老师和学生

定义老师和学生类，然后写代码测试，找到老师和学生类当中共性，抽取一个父类用继承方式写代码，并测试

1定义老师类，姓名年龄，教书

2定义学生类，姓名年ing学习

定义测试类写代码测试

共性抽取父类，定义人类姓名年龄

定义教师类，继承人类，给出自己特有方法，教书

定义学生类，继承人类，给出自己特有方法，学习

定义测试类，写代码测试

012

猫和狗：继承的思想实现猫和狗案例，测试类中测试

猫：成员变量，姓名年龄

构造方法，无参，带参

成员方法，getset,,,,抓老鼠

狗：成员变量，姓名年龄

构造方法，无参带参

成员方法:getset，，，，看门

共性：

成员变量：姓名年龄

构造方法：无参带参

成员方法：getset

013

package==文件夹

包就是用来对类进行分类管理

包的定义格式：package 包名

		package com.itheima(二级包)

014

import package.classname;

015

修饰符=权限修饰符+状态修饰符

权限修饰符：

016状态修饰符

final最终态

static静态

public static String university（所有变量共享的大学）

共享的大学

继承：可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

父类：也称为基类，超类

子类：也称为派生类

继承中子类的特点：子类可以有父类的内容

子类还可以有自己特有内容

package com.itheima_01;

public class Fu {
    public void show(){
        System.out.println("show方法被调用");
    }
}

package com.itheima_01;

public class Zi extends Fu{
    public void method(){
        System.out.println("method方法被调用");
    }
}

package com.itheima_01;

public class Demo {
    public static void main(String[] args) {
        //类当中默认有无参构造方法
        Fu f = new Fu();
        f.show();

        Zi z =new Zi();
        z.method();
        z.show();
    }
}

002继承的优劣

好处：复用性高，提高维护性

弊端：继承使得类之间有了关系，类的耦合性增强，父类发生变化子类也变化，削弱了子类独立性

继承使用原则：is a

继承关系使用，A是B的一种，说明存在关系，可以考虑使用继承体现，否则就不能用继承

eg:苹果和水果，猫和动物，猫和狗

003继承中变量的访问特点：

子类方法中访问一个变量：优先级

1子类局部变量（方法内的）

2子类成员变量（类内部）

3父类成员变量

4报错（不考虑父亲的父亲）

004super关键字

package com.itheima_01;

public class Zi extends Fu{

    public int age=20;//如果子类有就不适用父类的
    public void show(){
        int age =30;//优先级：方法内部变量>成员变量>父类成员变量
        System.out.println(age);
        System.out.println(this.age);
        System.out.println(super.age);
    }
}

super关键字用法和this关键字用法相似：

this代表本类对象的引用

super代表父类存储空间的标识（父类对象的引用）

005继承中构造方法的访问特点：

子类中所有构造方法（有参无参）默认都会访问父类中无参构造方法

解释：子类会继承父类中数据，甚至使用父类数据，所以子类初始化之前一定先完成父类数据初始化

如果父类没有无参构造方法，只有带参构造方法，通过使用super关键字去显示调用父类的带参构造方法（无参带参最少有一个）

推荐自己给出无参构造方法

006

子类对象访问一个方法：

子类成员范围找

父类成员范围找

如果都没有就报错（不考虑父亲的父亲）

008

方法重写

子类中出现和父类一模一样方法声明，就需要方法重写

方法重写应用：子类需要父类的功能，功能主体子类有自己特有内容，可以重写父类中的方法，这样就沿袭了父类的功能，又定义了子类特有内容

@Override

检查以下方法是否重写父类：报错就不是重写父类，不报错是重写父类方法

009方法重写注意事项

父类私有private方法子类不能重写

子类重写父类方法，访问权限不能更改权限大于等于父类权限

例如public大于默认的

public>默认>私有

010继承注意事项

类支持单继承，不可以多继承

类支持多层继承

011

一旦有带参构造，如果要使用无参构造就要重新声明

有带参构造，默认无参就不能用，除非重写

012

猫和狗

013

package

import 包名 . 类名

015

权限修饰符

private 不能被继承类引用，

默认

protected

public 不同包无关类

016状态修饰符

final方法不可以继承类重写，但是可以用

final修饰成员变量，值不可以改变

final类不能被继承

017final修饰局部变量

final+基本类型=数据不能改变

final+引用类型=引用类型地址不嫩变，数值可以改变

018

static静态的意思

static修饰类的成员变量==所有变量共享同一数据

001

多态：同一个对象在不同时刻表现出来的不同形态

多态的前提和体现：

有继承/实现关系

有方法重写

有父类引用指向子类对象

多态的体现：继承，重写，指向

多态中成员访问特点

成员变量：编译看左边，执行看左边（父）

成员方法：编译看左边，执行看右边（子）

成员变量用父类，成员方法用子类

成员方法和成员变量访问不一样：因为成员方法有重写，成员变量没有重写

package com.itheima_13;

public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package com.itheima_13;

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;

    @Override
    public void eat() {
        //
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("捉迷藏");
    }
}

package com.itheima_13;

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

        Animal a = new Cat();//Animal决定成员变量和方法,编译看animal运行看右边cat

        System.out.println(a.age);//40
        //System.out.println(a.weight);
        a.eat();
        //a.playGame;
    }
}

调用类的类，可以写成调用类的父类，这样方便

多态的好处和弊端：

提高了程序的拓展性：定义方法时候，使用父类 作为参数，将来在使用时候，使用具体子类参与操作

多态弊端：不能使用子类特有功能

004

多态中转型（帮助使用子类中的特有功能）

向上转型：从子到父，父类引用指向子类对象

Animal a =new Cat();//子类对象赋值给父类引用——向上转型

向下转型：从父到子，父类引用转为子类对象

package com.itheima_13;

public class Animal {

    public void eat(){
        System.out.println("动物吃东西");
    }
}

package com.itheima_13;

public class Cat extends Animal {


    @Override
    public void eat() {
        //
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }

}

package com.itheima_13;

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a =new Cat();//子类对象赋值给父类引用——向上转型
        a.eat();
        //a.playGame();


/*
        Cat c =new Cat();
        c.eat();
        c.playGame();
*/
        Cat c = (Cat)a;//向下转型，Animal高，Cat低，所以向下
        c.eat();
        c.playGame();

    }
}

006

采用多态思想实现猫和狗案例

1定义动物类：

成员变量：姓名年龄

构造方法：无参带参

成员方法：setget

2定义猫类：继承动物类

构造方法：无参带参

成员方法：重写吃饭

3定义狗类：继承动物类

构造方法：无参，带参

成员方法：重写吃饭

4定义测试类：

007抽象类

一个没有方法体的方法应该定义为抽象方法，类中有抽象方法，该类必须定义为抽象类

关键字abstract，抽象方法必须存在于抽象类当中

抽象类参照多态方式创建对象：

抽象类子类要嘛重写抽象类的抽象方法，要嘛也是个抽象类

package com.abstractTest;

public abstract class Animal {
    public abstract void eat();
    public void sleep(){
        System.out.println("正在睡觉");
    }
}

package com.abstractTest;

public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

package com.abstractTest;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    @Override
    public void sleep() {
        super.sleep();
    }
}

package com.abstractTest;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal c = new Cat();
        c.eat();
        c.sleep();


        Animal d = new Dog();
        d.sleep();
        d.eat();
    }

}

008抽象类特点

抽象类和抽象方法必须使用abstract关键字修饰（public后）

public abstract class 类名()

public abstract void eat();

抽象类中不一定是抽象方法，抽象方法一定在抽闲类当中

抽象类不能实例化，可以参照子类对象实例化，这叫抽象多态

抽象类的子类：要嘛重写抽象类中所有抽象方法，要嘛就是抽象类

类=成员变量+构造方法+成员方法

009抽象类成员特点

成员变量可以是变量，也可以是常量

构造方法：有构造方法但是不能实例化

构造方法作用是什么？用于子类访问父类数据的初始化

成员方法：可以有抽象方法，限定子类必须完成某些动作

也可以是非抽象方法，提高代码复用性

package com.abstractTest;

public abstract class Animal {
    private int age = 20;
    private String name = "北京";

    public Animal() {
    }

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public void show(){
        System.out.println(age);
        System.out.println(name);
    }
    public abstract void eat();

}

package com.abstractTest;

public class Cat extends Animal{

    public  void eat(){
        System.out.println("猫吃鱼");
    }
}

package com.abstractTest;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();

    }

}

010

package com.abstractTest;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

package com.abstractTest;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

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

package com.abstractTest;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

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


}

package com.abstractTest;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal c = new Cat();
        c.setName("加菲");
        c.setAge(3);
        c.eat();
        System.out.println(c.getName()+","+c.getAge());
        System.out.println("--------------");


        Animal d = new Dog();
        d.setName("旺财");
        d.setAge(5);
        d.eat();
        System.out.println(d.getName()+","+d.getAge());
    }

}

179接口

180接口特点

011

接口interface

接口是一种公共规范标准，只要符合标准所有人都可以用

Java中的接口体现对行为的抽象

012接口特点（interface）

package com.itheima_16;

public interface Jumpping {
    public abstract void jump();
    
}

package com.itheima_16;

public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

接口用关键字interface修饰

public interface 接口名{}

类实现接口用implement表示

public class 类名 implement 接口名{}

接口不能实例化，接口是抽象的

接口实例化参照多态方式，通过实现类对象实例化，这叫接口多态

多态形式，具体多态，抽象类多态，接口多态

多态前提：继承或者实现关系，方法重写，父类接口指向子类实现类对象

要嘛重写接口中所有抽象方法，要嘛抽象类

013接口成员特点

interImpl接口的实现方法

接口成员变量默认被final修饰，默认就是常量

可以通过接口名.成员变量 的方式直接访问

接口的成员变量默认带：public static final int num = 3;

接口成员方法是抽象的 默认带public abstract

接口没有构造方法

014猫和狗，接口版本

015

类可以继承Object,类可以继承多个接口

接口和接口之间是继承关系，一个接口可以继承多个接口