文章目录

前言
第三章第4节面向对象高级
- 继承格式
- 子类实例化内存分析
- super详解
- 重写,重写与重载的区别
- final关键字
- 抽象类
- 抽象类常见问题
- 接口
- 多态
- instanceof-1
- instanceof-2
- Object类概述
- API的使用
- toString
- equals
- 内部类概述
- 成员内部类
- 局部内部类
- 局部内部类1
- 局部内部类2
- 匿名内部类
- 匿名内部类注意事项
- 局部内部类使用final参数
- 静态内部类
- 包装类
- 可变参数
- 递归概述
- 递归实现阶乘
总结

前言

第三章第4节面向对象高级

继承格式

全参构造方法

右键-source-

Generate Constructor using Fields

无参构造方法

Generate Constructor from Superclass

Generate Getters and Setters

package day01;
/*** 继承:* 继承是java面向对象编程技术的一块基石, 因为它允许创建等级层次的类.* 继承是基于类继承父类的特征和行为, 使得子类对象 (实例) 具有父亲的实例域和方法, 或子类从父类继承方法, 使得子类具有父类相同的行为.* * 格式:*   class 父类{* }* *     class 子类extends 父类{*    }* @author jiajun.lin**人拥有的特征, 学生都有*学生在人的基础上*代码重复性很大, 复用性小*/
public class Demo1 {public static void main(String[] args){}
}//人类
class Person{private String name;private int age;//无参构造方法public Person() {super();// TODO Auto-generated constructor stub}//全参数构造方法public Person(String name, int age) {super();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;}//say方法public void say() {System.out.println("我是: "+name+", 我今年"+age+"岁了");}}//学生
class Student{private String name;private int age;private String school;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 String getSchool() {return school;}public void setSchool(String school) {this.school = school;}public Student() {super();// TODO Auto-generated constructor stub}public void say() {System.out.println("我是: "+name+", 我今年"+age+"岁了,我的学校: "+school);}
}

使用extends继承了父类的特征,可以减少代码的重复性,提高代码的可用性

package day01;
/*** 继承:* 继承是java面向对象编程技术的一块基石, 因为它允许创建等级层次的类.* 继承是基于类继承父类的特征和行为, 使得子类对象 (实例) 具有父亲的实例域和方法, 或子类从父类继承方法, 使得子类具有父类相同的行为.* * 格式:*   class 父类{* }* *     class 子类extends 父类{*    }* @author jiajun.lin**人拥有的特征, 学生都有*学生在人的基础上*代码重复性很大, 复用性小*/
public class Demo2 {public static void main(String[] args){Student2 s = new Student2();s.setName("张三");s.setAge(18);s.say();}
}//人类
class Person2{private String name;private int age;//无参构造方法public Person2() {super();// TODO Auto-generated constructor stub}//全参数构造方法public Person2(String name, int age) {super();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;}//say方法public void say() {System.out.println("我是: "+name+", 我今年"+age+"岁了");}}//学生
class Student2 extends Person2{}

子类还可以有自己的独特个性

继承了

子类实例化内存分析

继承的限制:
Java中只有单继承, 多重继承, 没有多继承
Java是一个孩子只能有一个爹,一个爹有多个孩子
Java是爷,爹,子的多重继承模式
c++有多继承,一个孩子有多个爹,是有问题的

先从孙,再从子,最后到爷上面去找

Stundent.super.setName

所谓的继承,其实就是子类拥有父类的地址而已

但是子类并不一定都可用操作父类的方法

因为权限修饰符

super详解

* super:* 通过super , 可以访问父类的构造方法* 通过super , 可以访问父类的属性* 通过super , 可以访问父类的方法无参构造方法必须存在

  否则就不能使用子类直接继承父类,会报错

  ```class Student2 extends Person2{public Student2() {//被省略了,因为当我们在调用子类的构造方法时,默认调用父类的构造方法super();}public Student2(String name, int age) {super(name, age);}}```通过super,可以访问父类构造方法

package day01;
/*** 继承:* 继承是java面向对象编程技术的一块基石, 因为它允许创建等级层次的类.* 继承是基于类继承父类的特征和行为, 使得子类对象 (实例) 具有父亲的实例域和方法, 或子类从父类继承方法, 使得子类具有父类相同的行为.* * 继承的限制:*        Java中只有单继承, 多重继承,   没有多继承* * super:*        通过super , 可以访问父类的构造方法*          通过super构造方法的代码,必须写在子类构造方法的第一行 ;this和super不能都调用*         通过super , 可以访问父类的属性*        通过super , 可以访问父类的方法* @author jiajun.lin**/
public class Demo3 {public static void main(String[] args){Student2 s = new Student2();s.say();}
}//人类
class Person2{private String name;private int age;//无参构造方法public Person2() {super();// TODO Auto-generated constructor stub}//全参数构造方法public Person2(String name, int age) {super();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;}//say方法public void say() {System.out.println("我是: "+name+", 我今年"+age+"岁了");}}//学生
class Student2 extends Person2{public Student2() {super("无名称",1);}}

package day01;
/*** 继承:* 继承是java面向对象编程技术的一块基石, 因为它允许创建等级层次的类.* 继承是基于类继承父类的特征和行为, 使得子类对象 (实例) 具有父亲的实例域和方法, 或子类从父类继承方法, 使得子类具有父类相同的行为.* * 继承的限制:*        Java中只有单继承, 多重继承,   没有多继承* * super:*        通过super , 可以访问父类的构造方法*          通过super构造方法的代码,必须写在子类构造方法的第一行 ;this和super不能都调用*         通过super , 可以访问父类的属性*        通过super , 可以访问父类的方法* @author jiajun.lin**/
public class Demo3 {public static void main(String[] args){Student2 s = new Student2();s.say();}
}//人类
class Person2{private String name;private int age;public String sex;//无参构造方法public Person2() {super();// TODO Auto-generated constructor stub}//全参数构造方法public Person2(String name, int age) {super();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;}//say方法public void say() {System.out.println("我是: "+name+", 我今年"+age+"岁了");}}//学生
class Student2 extends Person2{public Student2() {//默认,调用构造方法super("无名称",1);//调用属性super.sex = "男";//访问父类的方法super.setName("哈哈哈");}}

重写,重写与重载的区别

package day01;
/*** 重写 (override) 规则: 方法重写* * 1. 参数列表必须完全与被重写方法的相同;* 2. 返回类型必须完全与被重写方法的返回类型相同;* 3. 访问权限不能比父类中被重写的方法的访问权限更低, 例如: 如果父类的一个方法被声明为public, 那么在子类中重写该方法就不能声明为protected.* 4. 父类的成员方法只能被它的子类重写;* 5. 声明为static 和  private 的方法不能被重写, 但是能够被再次声明.* * 子类父类的方法, 子类想要自己独特的规则, 子类就需要对方法体进行更改* @author jiajun.lin**/
public class Demo2 {public static void main(String[] args) {Student s = new Student();s.say();}
}class Person{public void say() {System.out.println("锄禾日当午, 汗滴禾下土");}
}class Student extends Person{}

package day01;
/*** 重写 (override) 规则: 方法重写* * 1. 参数列表必须完全与被重写方法的相同;* 2. 返回类型必须完全与被重写方法的返回类型相同;* 3. 访问权限不能比父类中被重写的方法的访问权限更低, 例如: 如果父类的一个方法被声明为public, 那么在子类中重写该方法就不能声明为protected.* 4. 父类的成员方法只能被它的子类重写;* 5. 声明为static 和  private 的方法不能被重写, 但是能够被再次声明.* * 子类父类的方法, 子类想要自己独特的规则, 子类就需要对方法体进行更改* @author jiajun.lin**/
public class Demo2 {public static void main(String[] args) {Student s = new Student();s.say();}
}class Person{public void say() {System.out.println("锄禾日当午, 汗滴禾下土");}
}class Student extends Person{public void say() {System.out.println("床前明月光, 玻璃好上霜, 要不及时擦, 整不好得脏! ");}
}

如果没有传递参数,就会匹配到没有参数的方法,调用了父类的方法

package day01;
/*** 重写 (override) 规则: 方法重写* * 1. 参数列表必须完全与被重写方法的相同;* 2. 返回类型必须完全与被重写方法的返回类型相同;* 3. 访问权限不能比父类中被重写的方法的访问权限更低, 例如: 如果父类的一个方法被声明为public, 那么在子类中重写该方法就不能声明为protected.* 4. 父类的成员方法只能被它的子类重写;* 5. 声明为static 和  private 的方法不能被重写, 但是能够被再次声明.* * 子类父类的方法, 子类想要自己独特的规则, 子类就需要对方法体进行更改* @author jiajun.lin**/
public class Demo2 {public static void main(String[] args) {Student s = new Student();s.say();}
}class Person{public void say() {System.out.println("锄禾日当午, 汗滴禾下土");}
}class Student extends Person{public void say(String text) {System.out.println("床前明月光, 玻璃好上霜, 要不及时擦, 整不好得脏! ");}
}

第一点:重写的方法列表要相同,其实就是参数

第二点:返回类型相同

第三点问题

第四点:如果没有关系,就不能重写

第五点:static,静态本身就没有继承,静态没有对象

面试题目:

面试题:
Java中重写 (Override) 与重载(Overload) 的区别:
重载:一个类里的方法名称相同,参数列表的类型和类型顺序不同,参数列表长度(参数个数)不同
重写:不同类中,子类对父类方法的重写
1. 发生的位置
重载: 一个类中
重写: 子父类中
1. 参数列表限制
重载: 必然不同
重写: 必须相同
1. 返回值类型:
重载: 与返回值类型无关
重写: 返回值类型必须一致
1. 访问权限:
重载: 与访问权限无关
重写: 子的方法权限必须不能小于父的方法权限
1. 异常处理:bug处理(大范围包含小范围)
重载: 与异常无关

重写: 异常范围可以减少或删除, 但是不能抛出新的异常

package day01;
/*** 重写 (override) 规则: 方法重写* * 1. 参数列表必须完全与被重写方法的相同;* 2. 返回类型必须完全与被重写方法的返回类型相同;* 3. 访问权限不能比父类中被重写的方法的访问权限更低, 例如: 如果父类的一个方法被声明为public, 那么在子类中重写该方法就不能声明为protected.* 4. 父类的成员方法只能被它的子类重写;* 5. 声明为static 和  private 的方法不能被重写, 但是能够被再次声明.* * 子类父类的方法, 子类想要自己独特的规则, 子类就需要对方法体进行更改* @author jiajun.lin* * 面试题:*  Java中重写 (Override) 与重载(Overload) 的区别:*      重载:一个类里的方法名称相同,参数列表的类型和类型顺序不同,参数列表长度(参数个数)不同*       重写:不同类中,子类对父类方法的重写*         1. 发生的位置*           重载: 一个类中*           重写: 子父类中*       2. 参数列表限制*          重载: 必然不同*           重写: 必须相同*       3. 返回值类型:*          重载: 与返回值类型无关*           重写: 返回值类型必须一致*      4. 访问权限:*           重载: 与访问权限无关*            重写: 子的方法权限 必须 不能小于父的方法权限*       5. 异常处理:bug处理(大范围包含小范围)*            重载: 与异常无关*          重写: 异常范围可以减少或删除, 但是不能抛出新的异常**/
public class Demo2 {public static void main(String[] args) {Student s = new Student();s.say();}
}class Person{public void say() {System.out.println("锄禾日当午, 汗滴禾下土");}
}class Student extends Person{public void say(String text) {System.out.println("床前明月光, 玻璃好上霜, 要不及时擦, 整不好得脏! ");}
}

final关键字

/**

final关键字:
final用于修饰属性, 变量.
变量成为了常量, 无法对其再次进行赋值.
final修饰的局部变量, 只能赋值一次 (可以先声明后赋值)
final修饰的是成员属性, 必须在声明时赋值.
全局变量( public static final )
常量的命名规范:
由1个或多个单词组成, 单词与单词之间必须使用下划线隔开, 单词中所有字母大写
例如: SQL_INSERT
final用于修饰类:
final修饰的类, 不可以被继承.
final用于修饰方法:
final修饰的方法, 不能被子类重写.
权限: 访问位置
@author jiajun.lin
*
*/

抽象类

抽象类不能new,不能被实例化

Browse

Person.java

package day01;/*** 抽象类**/
public abstract class Person {//抽象的方法public abstract void say();
}

Student.java

package day01;//1.abstract
public class Student extends Person{@Override  public void say() {System.out.println("我是学生, 好好学习, 天天向上.");}
}

Nurse.java

package day01;public class Nurse extends Person {@Override      //注解:重写public void say() {System.out.println("我是护士, 我的技术棒棒的");}}

Demo2.java

package day01;public class Demo2 {public static void main(String[] args) {Student s = new Student();s.say();Nurse n = new Nurse();n.say();}
}

存储方式是什么呢?

进库存储和查询存储

抽象类使用的频率比较少,接口比抽象类更抽象

抽象类常见问题

JVM可以将已经实现的创建出来

Person.java

package day01;/*** 抽象类**/
public abstract class Person {//无参构造方法public Person() {System.out.println("构造方法执行了");}//抽象的方法public abstract void say();
}

Student.java

package day01;//1.abstract
public class Student extends Person{@Override  public void say() {System.out.println("我是学生, 好好学习, 天天向上.");}
}

Nurse.java

package day01;public class Nurse extends Person {@Override      //注解:重写public void say() {System.out.println("我是护士, 我的技术棒棒的");}}

Demo2.java

package day01;public class Demo2 {public static void main(String[] args) {Student s = new Student();s.say();Nurse n = new Nurse();n.say();}
}

抽象类的父类没有实现方法体,方法体由子类去实现

接口

implement 重点

错

Person.java

package com.ljj.demo1;public interface Person {void say();}

Student.java

package com.ljj.demo1;public class Student implements Person{@Overridepublic void say() {System.out.println("锄禾日当午, 汗滴禾下土");}}

Demo1.java

package com.ljj.demo1;public class Demo1 {//public static final是被省略的//public static final int a = 10;public static void main(String[] args) {Student s = new Student();s.say();}}

多态

Person.java

package com.ljj.demo1;public interface Person {void say();}

Student.java

package com.ljj.demo1;public class Student implements Person{@Overridepublic void say() {System.out.println("锄禾日当午, 汗滴禾下土");}}

Nurse.java

package day01;public class Nurse extends Person {@Override      //注解:重写public void say() {System.out.println("我是护士, 我的技术棒棒的");}}

Demo2.java

package day01;public class Demo2 {//父类引用指向子类对象public static void main(String[] args) {//pPerson p = null;//sStudent s = new Student();p = s;  //右边是左边的一种形态p.say();}
}

package day01;public class Demo2 {public static void main(String[] args) {Student a = new Student();Nurse b = new Nurse();Person p1 = a;Person p2 = b;p1.say();p2.say();}
}

类型转换出错哦

学生是护士,护士不是学生

怎么面向接口编程?

Person.java

package com.ljj.demo1;public interface Person {void say();}

Student.java

package com.ljj.demo1;public class Student implements Person{@Overridepublic void say() {System.out.println("锄禾日当午, 汗滴禾下土");}}

Demo1.java

package com.ljj.demo1;public class Demo1 {public static void main(String[] args) {Student s = new Student();say(s);}public static void say(Person p) {p.say();}
}

以此为基础,学生这个类不够用了,加护士这个类

alt+/补全代码

package com.ljj.demo1;public class Nurse implements Person{@Overridepublic void say() {System.out.println("后续增加的say, 来自护士");}}

instanceof-1

package com.ljj.demo1;public class Demo2 {public static void main(String[] args) {Nurse n = new Nurse();say(n);}public static void say(Person p) {//如何判断传入的对象 是 此类型的哪种形态 或 哪一子类的对象Student s = (Student)p;s.say();}
}

instanceof-2

package com.ljj.demo1;public class Demo2 {public static void main(String[] args) {Nurse n = new Nurse();say(n);}public static void say(Person p) {//如何判断传入的对象 是 此类型的哪种形态 或 哪一子类的对象if(p instanceof Student) {Student s = (Student)p;s.say();}else {System.out.println("必须传入学生形态, 才可执行");}}
}

package com.ljj.demo1;public class Demo2 {public static void main(String[] args) {//传入护士形态Nurse n = new Nurse();say(n);//传入学生形态Student s = new Student();say(s);}public static void say(Person p) {//如何判断传入的对象 是 此类型的哪种形态 或 哪一子类的对象if(p instanceof Student) {Student s = (Student)p;s.say();}else {System.out.println("必须传入学生形态, 才可执行");}}
}

Object类概述

万物皆对象

Object类是所有类的父类

package com.ljj.demo2;public class Demo1 {public static void main(String[] args) {String text = "123";say(text);int a = 10;say(a);}public static void say(Object o) {System.out.println(o);}
}

API的使用

Ctrl+鼠标左键查看类的源代码

中文API

索引

toString

Person.java

package com.ljj.demo2;public class Person {private String name;private int 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 Person(String name, int age) {super();this.name = name;this.age = age;}public Person() {super();// TODO Auto-generated constructor stub}}

Demo2.java

package com.ljj.demo2;public class Demo2 {public static void main(String[] args) {//其实是在调用类Person的toString方法Person p = new Person("张三", 18);System.out.println(p);}}

System.out.println§; 就是下面的

System.out.println(p.toString());

toString不能直接描述我们的对象

需要重写toString

Person.java

package com.ljj.demo2;public class Person {private String name;private int 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 Person(String name, int age) {super();this.name = name;this.age = age;}public Person() {super();// TODO Auto-generated constructor stub}public String toString() {return "这是一个人";}
}

Demo2.java

package com.ljj.demo2;public class Demo2 {public static void main(String[] args) {//其实是在调用类Person的toString方法Person p = new Person("张三", 18);System.out.println(p.toString());}}

以后所有的类都要重写toString,去描述内容信息

Person.java

package com.ljj.demo2;public class Person {private String name;private int 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 Person(String name, int age) {super();this.name = name;this.age = age;}public Person() {super();// TODO Auto-generated constructor stub}public String toString() {return "这是一个人, 这个人的姓名: "+this.name+" ,这个人的年龄: "+this.age;}
}

Demo2.java

package com.ljj.demo2;public class Demo2 {public static void main(String[] args) {//其实是在调用类Person的toString方法Person p = new Person("张三", 18);System.out.println(p);Person p2 = new Person("李四",18);System.out.println(p2);}}

或者使用快捷键

Source-

Generate toString() -

equals

相当于比较两个对象的内存地址

看下equals这个方法

所以需要重写euqals方法

equals:

自反性:自己跟自己比 x.equals(x)

对称性: x和y x.equals(y) y.equals(x)

传递性: x,y,z x.equals(y) y.equals(z)

一致性: 未修改对象上的equals比较中使用的信息, 多次调用x.equals(y) 始终返回true或始终返回false

非空性: 非空参考值,x.equals(null)应该返回false.

public boolean equals(Object o) {//地址if (this == o) {return true;}//是否为空if (o == null) {return false;}//类型是否相同if (o instanceof Person) {//this类型与p2是类型比较Person p2 = (Person) o;if (this.name.equals(p2.name) && this.age == p2.age) {return true;}else {return false;}}else {return false;}}

开始简化

简化1

public boolean equals(Object o) {//地址if (this == o) {return true;}//是否为空if (o == null) {return false;}//类型是否相同if (o instanceof Person) {//this类型与p2是类型比较Person p2 = (Person) o;if (this.name.equals(p2.name) && this.age == p2.age) { //相同return true;}}else {return false;}return false; }

简化2

public boolean equals(Object o) {//地址if (this == o) {return true;}//是否为空if (o == null) {return false;}//类型是否相同if (o instanceof Person) {//this类型与p2是类型比较Person p2 = (Person) o;if (this.name.equals(p2.name) && this.age == p2.age) { //相同return true;}}return false; }

整体代码:

Person.java

package com.ljj.demo2;public class Person {private String name;private int 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 Person(String name, int age) {super();this.name = name;this.age = age;}public Person() {super();// TODO Auto-generated constructor stub}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}public boolean equals(Object o) {//地址if (this == o) {return true;}//是否为空if (o == null) {return false;}//类型是否相同if (o instanceof Person) {//this类型与p2是类型比较Person p2 = (Person) o;if (this.name.equals(p2.name) && this.age == p2.age) { //相同return true;}}return false; }}

Demo2.java

package com.ljj.demo2;public class Demo2 {public static void main(String[] args) {//其实是在调用类Person的toString方法Person p1 = new Person("张三", 18);Person p2 = new Person("张三",18);System.out.println(p1.equals(p2));}}

年龄

equals会根据业务去调整

快捷键source

内部类概述

成员内部类

Outer.java

package com.ljj.demo2;public class Outer {private int x;public int getX() {return x;}public void setX(int x) {this.x = x;}class Inner{public void say() {System.out.println("x="+x);}}
}

Demo1.java

package com.ljj.demo2;public class Demo1 {//要调用内部类, 必须有个外部类的对象, 通过外部类去引出内部类的对象public static void main(String[] args) {Outer o = new Outer();Outer.Inner i = o.new Inner();i.say();}}

Demo1.java

Outer.java

再来修改下Outer.java

局部内部类

package com.ljj.demo2;public class Demo3 {public static void main(String[] args) {class Person{public void say() {System.out.println("锄禾日当午, 汗滴禾下土");}}Person p = new Person();p.say();}}

好像没有啥意义.

但是其实是有特定的使用场景

局部内部类的使用

不是那么重要

Person.java

package com.ljj.demo2;public interface Person {void say();
}

Demo3.java

package com.ljj.demo2;public class Demo3 {public static void main(String[] args) {class PersonImp implements Person{@Overridepublic void say() {System.out.println("新编写的局部内部类的say方法内容");}}PersonImp p = new PersonImp();haha(p);}//仅用一次public static void haha(Person p) {}
}

使用系统的某个API,来演示局部内部类的使用

Java后端开发是专门的

Demo4.java

package com.ljj.demo2;import java.awt.Frame;public class Demo4 {public static void main(String[] args) {Frame f = new Frame("QQ登陆");f.setVisible(true);//表示显示f.setSize(300,200);}}

Demo4.java

package com.ljj.demo2;import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;public class Demo4 {public static void main(String[] args) {Frame f = new Frame("QQ登陆");f.setVisible(true);//表示显示f.setSize(300,200);class MyWindowListener implements WindowListener{@Overridepublic void windowOpened(WindowEvent e) {// TODO Auto-generated method stub}@Overridepublic void windowClosing(WindowEvent e) {// TODO Auto-generated method stubSystem.out.println("哈哈哈");}@Overridepublic void windowClosed(WindowEvent e) {// TODO Auto-generated method stub}@Overridepublic void windowIconified(WindowEvent e) {// TODO Auto-generated method stub}@Overridepublic void windowDeiconified(WindowEvent e) {// TODO Auto-generated method stub}@Overridepublic void windowActivated(WindowEvent e) {// TODO Auto-generated method stub}@Overridepublic void windowDeactivated(WindowEvent e) {// TODO Auto-generated method stub}}MyWindowListener l = new MyWindowListener();f.addWindowListener(l);}}

局部内部类1

不是太有意义

老是关注过程,很累

局部内部类的使用

Person.java

Demo3.java

面向抽象,面向接口

传入Person实现类的对象

局部内部类2

Demo3.java

实际应用场景:

接下来不是知识点

使用系统的某个API, 来演示局部内部类的使用

匿名内部类

属于局部内部类的一种

只使用一次的类

匿名内部类

引用接口的匿名实现类

不起名字,只使用一次

匿名内部类注意事项

局部内部类使用final参数

所有局部内部类都只能访问final型的局部变量

默认final int a = 10;

1.8之前必须加final

反编译,去查看内部代码结构

9-15必须单独存在一个文件里,与Demo3无关

先在9-15设置变量,做了个备份a,

外边a=10; 意味在PersonImp内部备份了a=10;

但是如果后来重新设定a的值,就会导致逻辑错误

内部类被单独编译为一个字节码文件

内部变量a与外部变量a必须一致,系统要求的不能更改,所以默认加了final

静态内部类

静态不能访问非静态

静态只能访问静态

内部类的应用极其少,是不是重点记忆的知识点

包装类

好处:

1.当作对象去传递

2.比基础类型有更多的操作方法

把一个值装到包装里 integer -> int

把包装还原到int -> integer

已过时的操作(斜线)

过时后要用什么去替代

自动开箱和自动装箱

上面不合理

这样才合理

8个包装类都是重点

可变参数

现在需求变了

求三个数的和

这样构成方法重载

现在的需求是不知道要多少个参数

怎么办?

很多java程序员都不会用可变参数

递归概述

重点

引入递归前,思考一个问题:

不允许使用循环怎么办?

自己调用自己,绕不出去,栈内存溢出

递归实现阶乘

5*(4*3*2*1)

运算结果不能返回,就不会停止运算

fact(n)->…->fact(1)

fact(5)<-…<-fact(1)

递归的效率比较低

总结

Java大数据-Week2-Day3面向对象高级相关推荐

Java大数据学习第六天------面向对象类对象封装
面向过程: 强调的是过程, 面向对象: 强调的是结果,只需要关注结果就好. 面向对象的三大特征: 封装: 把相关的数据封装成一个"类"组件继承: 是子类自动共享父类属性和 ...
Java和Java大数据有什么区别？
单单提起java或者大数据,很多人对此都一目了然,但对于Java大数据这样一个新鲜名词,多少有些疑惑.那java和java大数据学习的内容是一样的吗?两者有什么区别呢?今天就从java和java大数据 ...
选择java大数据开发方向学习，应该怎么规划学习路线
Java是目前使用广泛的编程语言之一,具有的众多特性,特别适合作为大数据应用的开发语言.Java语言功能强大和简单易用,不仅吸收了C++语言的各种优点还摒弃了C++里难以理解的多继承.指针等概念. J ...
2021年Java大数据难不难学
2021年Java大数据难不难学有Java基础学大数据的话会简单一些,Java和大数据是两种不同行业,Java是一个强类型编程语言,拥有极高的跨平台能力,如果是Java程序员想升级做大数据开发就会容 ...
一直在说的Java和Java大数据，你能搞清楚吗？
提起Java或大数据,很多人对此都一目了然,但对于Java大数据这样一个新鲜名词,多少有些疑惑. 那Java和Java大数据学习的内容是一样的吗?两者有什么区别呢?今天就从Java和Java大数据的以 ...
Java第四次作业——面向对象高级特性（继承和多态）
Java第四次作业--面向对象高级特性(继承和多态) (一)学习总结 1.学习使用思维导图对Java面向对象编程的知识点(封装.继承和多态)进行总结. 2.阅读下面程序,分析是否能编译通过?如果不能, ...
python大数据和java大数据的区别-未来Java、大数据、Python哪个前景更好，薪资更高？...
都知道现在最火爆的是人工智能.大数据.而人工智能和大数据主要用的语言就是Java和Python.今天我们就来分析一下,当前java,python和大数据,哪个就业前景更好?自己该学哪一个? Java和 ...
java大数据开发做什么你知道吗？大数据的职业发展规划
你想过自己的未来规划吗? java大数据程序员只需要学到技术就行吗? 1.如何成为大数据工程师 Java开发是IT行业的经典岗位,行业当中存在普遍的需求,Web开发.Android开发. ...
为什么Java大数据是最火爆的编程语言？
未来10年将是大数据,人工智能爆发的时代,到时将会有大量的企业需要借助大数据,而Java最大的优势就是它在大数据领域的地位,目前很多的大数据架构都是通过Java来完成的. 在这个Android.iOS ...
大数据时代，为什么很多JAVA程序员会转型做JAVA大数据
分享之前推荐一个大数据交流学习群:722680258零基础进阶高级,需要学习大数据欢迎加入 JAVA的精密,强大,拥有其它语言不可替代的性能和可维护性,早已经是成为最受欢迎的编程语言之一,很多人想进入 ...

Java大数据-Week2-Day3面向对象高级

文章目录

前言

第三章第4节面向对象高级

继承格式

子类实例化内存分析

super详解

重写,重写与重载的区别

final关键字

抽象类

抽象类常见问题

接口

多态

instanceof-1

instanceof-2

Object类概述

API的使用

toString

equals

内部类概述

成员内部类

局部内部类

局部内部类1

局部内部类2

匿名内部类

匿名内部类注意事项

局部内部类使用final参数

静态内部类

包装类

可变参数

递归概述

递归实现阶乘

总结

Java大数据-Week2-Day3面向对象高级相关推荐

最新文章

热门文章

Java大数据-Week2-Day3面向对象高级

文章目录

前言

第三章第4节 面向对象高级

继承格式

子类实例化内存分析

super详解

重写,重写与重载的区别

final关键字

抽象类

抽象类常见问题

接口

多态

instanceof-1

instanceof-2

Object类概述

API的使用

toString

equals

内部类概述

成员内部类

局部内部类

局部内部类1

局部内部类2

匿名内部类

匿名内部类注意事项

局部内部类使用final参数

静态内部类

包装类

可变参数

递归概述

递归实现阶乘

总结

Java大数据-Week2-Day3面向对象高级相关推荐

最新文章

热门文章

第三章第4节面向对象高级