黑马程序员 Java基础面向对象2

最新推荐文章于 2021-04-13 15:53:09 发布

hn196828828

最新推荐文章于 2021-04-13 15:53:09 发布

阅读量356

点赞数

本文链接：https://blog.csdn.net/hn196828828/article/details/47653529

版权

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一 final关键字

1）是最终的意思，可以修饰类，方法，变量。

2）特点：

A:它修饰的类，不能被继承。

B:它修饰的方法，不能被覆盖（重写）。

C:它修饰的变量，是一个常量。

3）面试相关：

A:局部变量

a:基本类型值不能发生改变

b:引用类型地址值不能发生改变，但是对象的内容是可以改变的

B:初始化时机

a:只能初始化一次。

b:常见的给值

定义的时候。(推荐)

构造方法中。

二多态

1）多态的前提：

A:有继承或者实现关系。

B:有方法重写。

C:有父类或者父接口引用指向子类对象。

2）多态的分类：

a:具体类多态

b:抽象类多态

c:接口多态

3）多态中的成员访问特点

A:成员变量

编译看左边，运行看左边

C:成员方法

编译看左边，运行看右边

D:静态方法

编译看左边，运行看左边

为什么?

因为成员方法有重写。

4）案例

代码1：

/*

看程序写结果

 

继承的时候：

子类中有和父类中一样的方法，叫重写。

子类中没有父亲中出现过的方法，方法就被继承过来了。

*/

 

class A {

public void show() {

show2();

}

public void show2() {

System.out.println("我");

}

}

class B extends A {

/*

public void show() {

show2();

}

*/

 

public void show2() {

System.out.println("爱");

}

}

class C extends B {

public void show() {

super.show();

}

public void show2() {

System.out.println("你");

}

}

public class DuotaiTest4 {

public static void main(String[] args) {

A a = new B();

a.show();

B b = new C();

b.show();

}

}

易错，当时自己就错了。输出结果是“爱你”

代码2：

多态继承中的内存图解

由这个图来想上一个例子。方法区中的Zi的函数，首先继承自父类中的函数，因为本例中子类中重写了show（）方法，所以show（）是重写后的函数。而上一例子中，show（）有的，只是是父类继承来的，不是自己写的。

三抽象类

1）抽象类不能实例化。原因：调用抽象方法没有意义

2）抽象类的几个小问题

A：抽象类有构造函数。

虽然不能给自己的对象初始化，但是可以给自己的子类对象初始化。

B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?

为了不让创建对象

C:abstract不能和哪些关键字共存

a:final 冲突

b:private 冲突

c:static 无意义

3）抽象类和一般类的不同：

①一般类可以具体的描述事物。

②抽象类描述事物的信息不具体

④一般类可以创建对象，而抽象类不能创建对象。

4）按照多态的方式来实例化

Animal a = new Cat();

5）案例：

代码1：

abstract class Animal{

public abstract void eat();

 

public Animal(){}

}

 

class Cat extends Animal{

public void eat(){

System.out.println("猫吃鱼");

}

}

 

public class AbstractDemo {

public static void main(String[] args) {

Animal a = new Cat();

a.eat();

}

}

四接口

1）接口的特点：

A:接口用关键字interface修饰

interface 接口名 {}

B:接口与接口

继承关系，可以单继承，也可以多继承

C:规律总结

A:具体类多态(几乎没有)

B:抽象类多态(常用)

C:接口多态(最常用)

2）接口的成员特点：

A:成员变量

默认修饰符：public static final

B:构造方法

没有构造方法

C:成员方法

默认修饰符：public abstract

接口中的成员都是公共的。

3）抽象类和接口的区别(自己补齐)?

抽象类和接口的区别：

A:成员区别

抽象类：

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

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量

成员方法：只可以抽象

B:关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

C:设计理念区别

抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

4）案例

代码1：

interface Inter{

public int num = 10;

public final int num2 = 20;

public static final int num3 = 30;

 

// 错误

// public Inter(){}

 

public void show();

}

 

//  接口名+Impl这种格式是接口的实现类格式

class InterImpl implements Inter{

public void show(){}

}

 

public class InerfaceDemo2 {

public static void main(String[] args) {

Inter i = new InterImpl();

System.out.println(i.num2);

// i.num = 100;  // 无法为最终变量num分配值

System.out.println(Inter.num2);

}

}

代码2：由这个来理解父类（或者说抽象类）和接口的现实意义上的区别

/*

老师和学生案例,加入抽烟的额外功能

分析：从具体到抽象

老师：姓名，年龄，吃饭，睡觉

学生：姓名，年龄，吃饭，睡觉

由于有共性功能，我们提取出一个父类，人类。

人类：

姓名，年龄

吃饭();

睡觉(){}

抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

抽烟接口。

 

部分老师抽烟：实现抽烟接口

部分学生抽烟：实现抽烟接口

实现：从抽象到具体

使用：具体

*/

//定义抽烟接口

interface Smoking {

//抽烟的抽象方法

public abstract void smoke();

}

 

//定义抽象人类

abstract class Person {

//姓名

private String name;

//年龄

private int age;

public Person() {}

public Person(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();

//睡觉(){}

public void sleep() {

System.out.println("睡觉觉了");

}

}

 

//具体老师类

class Teacher extends Person {

public Teacher() {}

public Teacher(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("吃大白菜");

}

}

 

//具体学生类

class Student extends Person {

public Student() {}

public Student(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("吃红烧肉");

}

}

 

//抽烟的老师

class SmokingTeacher extends Teacher implements Smoking {

public SmokingTeacher() {}

public SmokingTeacher(String name,int age) {

super(name,age);

}

 

public void smoke() {

System.out.println("抽烟的老师");

}

}

 

//抽烟的学生

class SmokingStudent extends Student implements Smoking {

public SmokingStudent() {}

public SmokingStudent(String name,int age) {

super(name,age);

}

 

public void smoke() {

System.out.println("抽烟的学生");

}

}

 

class InterfaceTest2 {

public static void main(String[] args) {

//测试学生

SmokingStudent ss = new SmokingStudent();

ss.setName("林青霞");

ss.setAge(27);

System.out.println(ss.getName()+"---"+ss.getAge());

ss.eat();

ss.sleep();

ss.smoke();

System.out.println("-------------------");

SmokingStudent ss2 = new SmokingStudent("刘意",30);

System.out.println(ss2.getName()+"---"+ss2.getAge());

ss2.eat();

ss2.sleep();

ss2.smoke();

//测试老师留给自己练习

}

}

其实，多态等概念的实际理解，要放在后面学习的部分或者说，是在以后学习工作中，不断积累经验，丰富对它的认识的。现在理解的都很浅。

尤其可以结合以后的设计模式看。

因为面向对象思维，根本的在于用计算机或者说编程思维模拟现实世界，现实世界的逻辑是多样的，所以最终实现的手段也是多样的，所以经验很重要，才可以更好的理解多态等的思维。

五包

1）其实就是文件夹

2）作用：

A:区分同名的类（同一个包下不能有同名的类）

B:对类进行分类管理

a:按照功能分

b:按照模块分

3）包的定义：

package 包名;

4）注意事项：

package语句必须在文件中的第一条有效语句
5）导包

import 包名...类名;

另一种：

import 包名...*;(不建议)

六权限修饰符

1 权限修饰符

本类同一个包下不同包下的子类不同包下的无关类

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

七内部类

1 把类定义在另一个类的内部，该类就被称为内部类。

2 内部类的访问规则

A:可以直接访问外部类的成员，包括私有

B:外部类要想访问内部类成员，必须创建对象

class Outer{

private int num = 10;

 

class Inner{

public void show(){

System.out.println(num);

}

}

 

public void method(){

// show();

 

Inner i = new Inner();

i.show();

}

}

3 分类（同成员变量、局部变量的分类方法）

A:成员内部类

B:局部内部类

4 成员内部类

A:private 为了数据的安全性

B:static 为了访问的方便性

成员内部类不是静态的：

外部类名.内部类名对象名 = new 外部类名.new 内部类名();

成员内部类是静态的：

外部类名.内部类名对象名 = new 外部类名.内部类名();

代码1：

class Body {

    private class Heart {

        public void operator() {

            System.out.println("心脏搭桥");

        }

    }

    

    public void method() {

        if("你是外科医生") {

            Heart h = new Heart();

            h.operator();

        }

    }

}

 

public class InnerClassDemo4 {

public static void main(String[] args) {

//Body.Heart bh = new Body().new Heart();

//        bh.operator();

Body b =  new Body();

        b.method();

    }

}

代码2：

class Outer{

private int num = 10;

private static int num2 = 100;

 

public static class Inner{

public void show(){

//System.out.println(num); //静态内部类访问的外部类数据必须用静态修饰。

System.out.println(num2);

}

public static void show2(){

//System.out.println(num);

System.out.println(num2);

}

}

}

 

public class InnerClassDemo4 {

public static void main(String[] args) {

//Outer.Inner oi = new Outer().new Inner(); 错误的访问方式

//oi.show();

//oi.show2();

 

 Outer.Inner oi = new Outer.Inner();

 oi.show();

 oi.show2();

 

 Outer.Inner.show2();

    }

}

5 局部内部类

A:局部内部类访问局部变量必须加final修饰。

B:为什么呢?

因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。

所以，堆内存还是用该变量，而改变量已经没有了。

为了让该值还存在，就加final修饰。

通过反编译工具我们看到，加入final后，堆内存直接存储的是值，而不是变量名。

class Outer{

private int num = 10;

 

public void method(){

final int num2 = 200;

class Inner{

public void show(){

System.out.println(num);

System.out.println(num2);  // 需要被声明为最终类型

}

}

 

Inner i = new Inner();

i.show();

}

}

 

public class InnerClassDemo5 {

public static void main(String[] args) {

Outer o = new Outer();

o.method();

}

}

6 匿名内部类

A:是内部类的简化写法。

B:前提

存在一个类（具体类也可以是抽象类）或者接口

C:本质：

其实是继承该类或者实现接口的子类匿名对象

interface Inter{

public abstract void show();

public abstract void show2();

}

 

class Outer{

public void method(){

Inter i = new Inter(){

 public void show() {

                System.out.println("show");

            }

            

            public void show2() {

                System.out.println("show2");

            }

};

 

i.show();

i.show2();

}

}

 

public class InnerClassDemo6 {

public static void main(String[] args) {

Outer o = new Outer();

o.method();

}

}

7 匿名内部类在开发中的使用

安卓开发比javaee中用到的多，因为匿名内部类使用后，就可以作为垃圾回收，不太占内存。

我们在开发的时候，会看到抽象类，或者接口作为参数。

而这个时候，我们知道实际需要的是一个子类对象。

如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

Comparator接口就是这样用的；Thread也是这样的

new Thread(new Runnable(){

}){

}.start();

八面向对象三大特征：封装、继承、多态

hn196828828

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员 Java基础面向对象2

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------一 final关键字1）是最终的意思，可以修饰类，方法，变量。2）特点：A:它修饰的类，不能被继承。B:它修饰的方法，不能被覆盖（重写）。C:它修饰的变量，是一个常量。3）面试相关：A:局部变量a:基本类型值不能发生改变b:引用类型地址值不能发生改变，但
复制链接

扫一扫