Java学习第十四天——匿名类与面向对象初解

一、匿名对象

 

1.1 创建对象的语法：

Person p1 = new Person();

//=左侧在做对象的声明，开辟的是栈内存

//=右侧，才是真正的创建对象

//结果：内存中，创建了一个对象，对象的地址，赋值给p1。

匿名对象，就是只有=右侧，没有=左侧。

new 构造方法(必要的参数);

匿名对象的用途：

1、使用匿名对象，直接调用类的方法。

2、匿名对象直接作为一个方法的参数。

注意点：

匿名对象只能使用一次。随着它的创建而使用一次。（一次性的）

它必须继承一个父类或者一个接口，因此这个匿名类会被默认为这个父类或者接口的子类或实现类

优势：

1、使用后即销毁，就是被GC回收。

2、代码书写方法，提高效率。

例；匿名类有两种：
 
        1、与子类有关的匿名类
 
        2、与接口有关的匿名类
 
 
1、与子类有关的匿名类
 
 class Demo29 {
 
    public static void main(String args[]) {
        Test test = new Test();
        Person person = new Boy();
        test.test(person);
        person = new Gril();
        test.test(person);
        test.test(new Boy());
        /**
         * 这里是与子类有关的匿名类的关键知识点
         * 这个匿名类相当与Boy，Gril类，这个是我不需要事先定义这个类，而是我什么时候要用，什么时候写一个匿名类，这种写法代表着其子类
        
         */
        test.test(new Person() {
            @Override
            void speak() {
 
                System.out.println("与子类有关的匿名类！");
            }
 
        });
    }
}
 
 abstract class Person {
    abstract void speak();
}
 
 
 class Boy extends Person {
    @Override
    void speak() {
        System.out.println("Boy");
    }
}
 
 class Gril extends Person {
    @Override
    void speak() {
        System.out.println("gril");
    }
}
 
 class Test {
 
    /**
     * 这个类就是纯粹的为了使用多态
     */
 
    void test(Person person) {
        person.speak();
    }
 
}
 

 

 

 

二、封装性

java封装的目的：私有化成员变量，避免有害代码（信息）的输入。

1、提高代码的安全性；

2、提高代码的复用性；

3、便于维护；

封装的对象；一个方法，一个类，都是一种封装。

 

面向对象的三大特征：

1、封装性

2、继承性

3、多态性

 

封装的概念：尽可能的隐藏对象的内部的细节。

"打包",包起来。为了保护数据的安全性。

某宝购物，电视机

面向对象中的封装性，不仅仅是对属性进行封装。

一段代码，写了3遍--->封装成一个方法

一堆方法，用了3遍--->封装成工具类：Arrays工具类

 

一个方法，一个类，都是一种封装。

 

 

2.1 private关键字

 

词义："私有的"。

 

是一个访问权限修饰符：

修饰符：public，private，static，final，abstract。。。

访问权限：在哪个范围内能够访问。

作用：限制在本类中才能访问。

private，修饰属性，修饰方法，不能修饰类。

 

2.2 getter和setter方法

为了保护属性的数据安全，使用了private访问权限修饰符，限制了只能在类中使用。

那么对于外部的对象，如何给属性进行操作？赋值，取值。

例；匿名类有两种：
 
        1、与子类有关的匿名类
 
        2、与接口有关的匿名类
 
 
1、与子类有关的匿名类
 
 class Demo29 {
 
    public static void main(String args[]) {
        Test test = new Test();
        Person person = new Boy();
        test.test(person);
        person = new Gril();
        test.test(person);
        test.test(new Boy());
        /**
         * 这里是与子类有关的匿名类的关键知识点
         * 这个匿名类相当与Boy，Gril类，这个是我不需要事先定义这个类，而是我什么时候要用，什么时候写一个匿名类，这种写法代表着其子类
        
         */
        test.test(new Person() {
            @Override
            void speak() {
 
                System.out.println("与子类有关的匿名类！");
            }
 
        });
    }
}
 
 abstract class Person {
    abstract void speak();
}
 
 
 class Boy extends Person {
    @Override
    void speak() {
        System.out.println("Boy");
    }
}
 
 class Gril extends Person {
    @Override
    void speak() {
        System.out.println("gril");
    }
}
 
 class Test {
 
    /**
     * 这个类就是纯粹的为了使用多态
     */
 
    void test(Person person) {
        person.speak();
    }
 
}
 

 

2.3 类的设计原则：

 

- 成员变量(属性)，私有化(使用private修饰)。添加getter方法和setter方法。

- 公开方法(public修饰)。

- 至少提供无参的构造方法，有参(随意)。

 

所以说对类中的属性，进行封装的步骤：

 

step1：使用private关键字，修饰成员变量(属性)。

step2：提供setter方法，用于对属性进行赋值。

public void set属性名(参数){

this.属性名 = 参数;

}

step3：提供getter方法，用于获取属性值。

public 属性值类型 get属性名(){

return this.属性名;

}

```

 

2.4 属性封装，

注意点：

如果一个属性是boolean类型的，get方法的写法：方法名是特殊：isXXX()

private boolean married;//是否已婚

 

//对于boolean类型的get方法：两个状态

public boolean isMarried(){

return this.married;

}

 

 

 

 

2.5 扩展内容：

数组有长度：表示该数组中存储的元素的个数。

数组的属性：arr.length

字符串也有长度：表示该字符串中字符的个数。

"abc"，"hello","he llo"

字符串的方法：str.length();

 

 

三、继承性

 

3.1 生活中的继承

 

继承"遗产"。

子承父业。儿子可以继承父亲的东西。

 

 

3.2 Java中的继承的概念

 

继承指的是两个类的关系。如果一个类(子类)，继承了另外一个类(父类)。

那么子类就可以直接使用父类的非私有化的成员(属性，和方法)。

 

2.3.3 继承的好处

 

1、实现代码的重用和扩展。

 

​ 避免重复的代码：父类写的非私有化的属性和方法，子类不用再写了，直接使用。

 

​ 类的扩展：思想，子类扩展父类的功能。(父类是人，子类是学生)

 

2、模拟现实世界的关系。

 

 

 

3.4 类的继承

 

- 关键字：extends，词义：扩展的。描述两个类的关系：子类，父类。

- 被继承的类：父类，根类，超类，基类，SuperClass

 

- 继承的类：子类，派生类，SubClass

 

 

 

3.5 继承的语法

public class FatherClass{

//属性

//方法

}



public class ChildClass extends FatherClass{

//新增的属性

//方法：重写，新增

}

 

 

一旦两个类存在了继承的关系，那么：

 

- 子类可以直接使用父类的非私有化的属性(成员变量)和方法(成员方法)。

 

- 子类还可以新增自己的属性和方法。

- 子类可以重写父类已有的方法。

 

 

 

3.6 什么样的两个类适合继承关系

 

要两个类，满足is-a 的范式

子类 是一个 特殊的 父类。

 

 

小汽车，继承 车

 

工人，继承人

 

学生，继承人

 

猫类：继承动物

 

​ name，age

 

​ eat()，sleep()

 

狗类：继承动物

 

​ name，age，color

 

​ eat()，sleep()

 

 

 

3.7 继承的注意点

 

1、两个类存在了继承关系。

子类可以使用父类的属性和方法

但是父类不能使用子类的属性和方法。

2、Java语言的继承是局限性：单继承。

一个子类，只能有一个父类。

Java语言，不允许多继承，但是可以多层继承。

一个父类，爷爷类，太爷爷，祖爷爷。。祖宗。。

一个父类是可以有多个子类的。

 

 

 

四 子类对象的创建过程

 

调用子类的构造方法中，先调用父类的构造方法。默认父类的无参构造方法。

记住：

1、子类的构造方法中，第一行一定是调用了父类的构造方法。

2、如果没有显示的调用父类的构造方法，编译器会自动的添加：super()。父类的无参构造。

3、子类的构造方法中，既可以调用父类的无参构造方法，也可以调用父类的有参构造方法。

4、父类的无参构造：super(),父类的有参构造：super(参数)。

4.1 super关键字

 

词义："超级的"

 

用法一：表示父类的构造方法。super()，表示父类的构造方法。同this()相类似。

 

​ 如果父类中，有多个构造方法，super(),指代哪个构造方法呢？靠参数来区分

 

​ super()，无参的父类构造方法

 

​ super(参数),有参的父类构造方法。

 

​ 指代父类的构造方法时，要位于首行。

 

 

 

总结

 

1、匿名对象：只有对象的创建，一次性的。只能使用一次。

 

2、封装性："打包"。

 

​ 方法

 

​ 类

 

​ 属性：

 

3、private关键字：访问权限修饰符。

 

使用了private修饰的属性和方法，在本类中才能使用

 

4、提供getter和setter方法。

 

 

public void setName(String name){

this.name = name;

}

 

public String getName(){

return this.name;

}

boolean类型的属性，get方法

public boolean isMarried(){

}

```

 

5、继承性：

 

一个子类，继承一个父类。 is - a。

 

- 子类可以直接访问父类的非私有的属性和方法。

- 子类可以新增自己的属性和方法

- 子类可以重写父类已有的方法。

 

语法：extends

 

java

class A{

 

}

 

class B extends A{

 

}

 

 

6、注意点：

 

​ 单继承，但是可以多层继承。

 

7、子类对象的创建：调用子类的构造方法。

 

- 在子类的构造方法中，第一行一定是父类的构造方法的调用。默认super()。如果没写，编译器自动添加。

- 如果想调用父类的有参构造：super(参数)。

- super()，位于子类构造方法的第一行。

 

 

引用备注；

引用1；原文链接：https://blog.csdn.net/qq_40990854/article/details/81067371