Java面向对象
Java面向对象
Java的核心思想就是OOP（Object-oriented programming）面向对象编程。
面向过程&面向对象
-
面向过程的思想——线性思维
- 步骤清晰简单，第一步做什么，第二步做什么… …
- 面向过程适合处理一些较为简单的问题
-
面向对象的思想
- 物以类聚，分类的思维模式，思考问题首先要解决哪些问题需要哪些分类，然后对这些分类单独思考。最后才对某个分类下的细节进行面向过程的思考。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
-
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体涉及到微观操作，我们仍然需要面向过程的思路去处理。
-
面向对象和面向过程某种意义上来说是不可分割的。
什么是面向对象
-
面向对象编程（Object-oriented programming，OOP）
-
面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织（封装）数据
-
抽象：把许多事物的共同点抽取剥离出来，变成一个类。
-
三大特性：
- 封装
- 继承
- 多态
-
从认识论的角度考虑是先有对象后有类，对象是以具体的事物。类是抽象的，是对对象的抽象的集合体
-
从代码运行角度考虑是现有类后有对象。类是对象的模板。
方法回顾
方法的定义
-
修饰符：是可选的，并且可以不只有一个，告诉编译器如何调用该方法，定义了该方法的访问类型。如
public、static等。 -
返回类型：方法可能会返回一个值，没有返回值则返回值类型关键字为
void。 -
break：跳出switch，结束循环；**return：**直接结束方法，返回一个结果（为空或其他类型）。
-
方法名：注意规范即可，见名知意。
-
参数列表：（参数类型 参数名……）
-
异常抛出：暂时遇到的异常：ArrayIndexOutOfBoundsException:数组下标越界异常！
方法的调用
静态方法：类名.方法名
新建一个学生类Student
// 学生类
public class Student {
// 静态方法
public static void say() {
System.out.println("学生说话了");
}
}
在另一个类中可以调用它的静态方法
public class Demo02 {
// 静态方法 static
public static void main(String[] args) {
Student.say();
}
}
结果：
学生说话了
非静态方法：通过new关键字实例化这个类
// 学生类
public class Student {
// 非静态方法
public void say() {
System.out.println("学生说话了");
}
}
在另一个类中可以调用它的非静态方法
public class Demo02 {
/**
非静态方法 new
通过new实例化这个类
*/
public static void main(String[] args) {
// 对象类型 对象名 = 对象值
Student student = new Student();
student.say();
}
}
结果：
学生说话了
这种情况是不可以的，相当于a方法在调用一个不存在的方法，b方法还没有实例化，无法被a调用。
// 和类一起加载的
public static void a(){
// b(); // 错误
}
// 类实例化之后才会存在
public void b(){
}
值传递
// 值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
Demo04.change(a);
System.out.println(a);
}
// 返回值为空
public static void change(int a){
a = 10;
}
}
结果：
1
1
我们只是把a的值传给change方法，并不会改变main方法中的a。
引用传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
// 没给name赋值前打印出来的是null
System.out.println(person.name);
Demo05.change(person);
// 输出刘同学
System.out.println(person.name);
}
public static void change(Person person) {
// person是一个对象，指向 ---> Person person = new Person();
// 这是一个具体的人，可以改变属性。本质还是传值。
person.name = "刘同学";
}
}
// 定义了一个Person类，有一个属性：name
class Person{
String name;
}
类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是不能代表某一个具体的事物。
- 动物、植物、手机、电脑……相当于一堆事物的统称。
- Person类、Pet类、Car类……这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
- 对象是抽象概念的具体实例。
- 比如张三就是人的一个实例，张三家里的旺财就是狗的一个实具体例。
- 能够体现出特点，展现出具体功能的是具体的实例，而不是一个抽象的概念。
创建与初始化对象
- 使用new关键字创建对象。
- 使用new关键字创建对象的时候，除了分配内存空间以外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
创建一个Student类：
public class Student {
// 属性
String name; // 默认null
int age; // 默认0
// 方法
public void study(){
System.out.println(this.name + "在学习");
}
}
创建一个Application类：
// 一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
// 类：抽象的，需要实例化
// 类实例化后会返回一个自己的对象
// student对象就是一个student类的具体实例
Student xiaoming = new Student();
Student xiaohong = new Student();
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
运行输出结果：
null
0
说明在我们使用new关键字创建对象的时候，除了分配内存空间以外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
当我们在Application类中加入以下代码：
xiaoming.name = "小明";
xiaoming.age = 19;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
输出结果变成：
小明
19
null
0
xiaohong没有被赋值则没有结果，输出的是初始化的值。
再度印证——面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织（封装）数据。
构造器
-
构造器
- 方法名和类名相同
- 没有返回值
- 没手动定义有参构造函数时，编译器会自动生成默认的无参构造函数。
-
作用
- new本质是在调用构造方法
- 初始化对象的值
-
注意
- 定义有参构造之后，如果想使用无参构造，必须显式地定义一个无参的构造。意思是如果我们在类中定义了有参构造函数，编译器将不会为我们自动生成默认的无参构造函数。
public class Person {
// 一个类即使什么都不写，他也会存在一个方法
// 显示的构造器
String name;
int age;
public Person() {
}
// alt + insert 用idea快捷生成构造器
// 1.使用new关键字，本质是在调用构造器
// 2.用来初始化值
// 有参构造：一旦定义了有参构造，无参就必须显示定义、
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
创建了一个Person类，什么都不写，编译器会为我们自动生成默认的无参构造函数。如果定义有参构造之后，想使用无参构造，必须显式地定义一个无参的构造。
// 一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
// new 实例化了一个对象
Person person = new Person("刘同学", 21);
System.out.println(person.name);
System.out.println(person.age);
}
}
Alt + insert也可以用右键呼出菜单选中Generate来替代。
内存分析
public class Pet {
public String name;
public int age;
// 无参构造
public void shout() {
System.out.println("叫了一声");
}
}
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
Pet cat = new Pet();
}
}
类与对象小结
- 类与对象
- 类是一个模板；抽象，对象是一个具体的实例。
- 方法
- 定义、调用。
- 对象的引用
- 引用类型： 基本类型（八大基本类型）
- 对象是通过引用来操作的：栈—>堆
- 属性
- 字段Field 成员变量
- 默认初始化：
- 数字：0、0.0
- char: u0000
- boolean: false
- 引用：null
- 修饰符 属性类型 属性名 = 属性值
- 对象的创建和使用
- 必须用new关键字创建对象，构造器 Person liu = new Person();
- 对象的属性 liu.name;
- 对象的方法 liu.sleep();
- 类：
- 静态的属性 属性
- 动态的属性 方法
面向对象的三大特征
封装
-
该露的露，该藏的藏
- 我们程序设计要追求**“高内聚 低耦合”**。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用 。
-
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而通过操作接口来访问，这称为信息隐藏。
-
记住这句话就够了：属性私有，get/set
创建学生类：
public class Student {
// 属性私有
private String name;
private int id;
private char sex;
private int age;
// 提供一些可以操作这个属性的方法
// 提供一些public的get、set方法
// get 获取这个数据
public String getName(){
return this.name;
}
// set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
// Alt + insert 快捷方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
// 不合法
if (age > 120 || age < 0) {
this.age = 3;
} else {
this.age = age;
}
}
}
在Application类中使用Student类中的封装的属性：
public class Student {
// 属性私有
private String name;
private int id;
private char sex;
private int age;
// 提供一些可以操作这个属性的方法
// 提供一些public的get、set方法
// get 获取这个数据
public String getName(){
return this.name;
}
// set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
// Alt + insert 快捷方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
// 不合法
if (age > 0 && age < 120) {
this.age = age;
} else {
System.out.println("输入不合法！");
}
}
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("刘同学");
System.out.println(s1.getName());
s1.setAge(999);
System.out.println(s1.getAge());
}
}
封装的意义
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高了系统的可维护性
方法的重载
方法名相同，参数列表不同。
继承
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
- extends意思是拓展，子类是父类的拓展。
- Java类中只有单继承，**没有多继承！**单继承是指一个类只能继承自一个父类（即只能有一个直接父类）。
- 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
- 子类与父类之间，从意义上讲应该具有"is a"的关系。
- 子类继承父类，会拥有父类的所有属性和方法（包括私有），但是私有属性和方法只是拥有，无法访问！
object类
创建Person（父类）
//在java中，所有的类 都直接或间接继承Object
public class Person /*extends Object*/ {
//私密程度由强到弱
//private（不能继承，但是可以用get和set来访问）
//protect
//public（可以继承）
private int money = 10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
// 快捷键Ctrl+H可以查看继承树
}
光标点击哪个类中的代码查看的就是哪个类的继承树。
创建Student（子类）
//学生 is 人 派生类（子类）
//子类继承父类，就会拥有父类的全部方法。
public class Student extends Person {
// 虽然什么都没写，但是子类拥有父类Person所有方法
}
创建Teacher（子类）
//老师 is 人 派生类（子类）
public class Teacher extends Person {
}
import oop.demo05.Student;
public class Application {
public static void main(String[] args) {
// 直接创建一个Student类的实例
Student student = new Student();
// 调用Student类的方法（继承自Person）
student.say();
// 父类中有的属性子类也都有
System.out.println(student.getMoney());
}
}
super
//在java中，所有的类 都直接或间接继承Object
public class Person /*extends Object*/ {
protected String name = "liu";
public void print(){
System.out.println();
}
}
//学生 is 人 派生类（子类）
//子类继承父类，就会拥有父类的全部方法。
public class Student extends Person {
private String name = "liutongxue";
public void test(String name){
// 直接输出传进来的name 刘同学
System.out.println(name);
// 输出本类中的name liutongxue
System.out.println(this.name);
// 输出父类中的name liu
System.out.println(super.name);
}
}
import oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("刘同学");
}
}
输出结果：
刘同学
liutongxue
liu
//在java中，所有的类 都直接或间接继承Object
public class Person /*extends Object*/ {
protected String name = "liu";
public void print(){ // 如果换成private则无法被继承
System.out.println("Person");
}
}
//学生 is 人 派生类（子类）
//子类继承父类，就会拥有父类的全部方法。
public class Student extends Person {
private String name = "liutongxue";
public void print(){
System.out.println("Student");
}
public void test1(){
// Student
print();
// Student
this.print();
// Person
super.print();
}
}
import oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
//student.test("刘同学");
student.test1();
}
}
输出结果：
Student
Student
Person
以上代码展示了super关键字的作用，继承到底是怎么继承的。
下面则是super的注意点：
- super调用父类的构造方法，必须在构造方法的第一个。
- super必须**只能出现在子类的方法或者构造方法****中！
- super和this不能同时调用构造方法！
super和this的对比：
- 代表对象不同
- this：本身调用者这个对象
- super：代表父类对象的应用
- 使用前提
- this：没有继承也可以使用
- super：只能在继承条件下才可以使用
- 构造方法
- this(); 本类的构造
- super(); 父类的构造
方法的重写
// 重写都是方法的重写，和属性无关
public class B {
// private不能重写
// 重写前静态方法：
//public static void test(){
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
// Override 重写
@Override // 注解：有功能的注释，只针对public
public void test() {
System.out.println("A=>test()");
}
}
import oop.demo05.A;
import oop.demo05.B;
public class Application {
// 静态方法和非静态方法的区别很大！
// 静态方法：方法的调用只和左边，定义的数据类型有关
// 非静态方法：重写
public static void main(String[] args) {
A a = new A();
a.test(); // A
// 父类的引用指向了子类
B b = new A(); // 子类重写了父类的方法
b.test(); // B
}
}
重写前：
A=>test()
B=>test()
重写后：
A=>test()
A=>test()
重写注意：需要有继承关系，子类重写父类的方法！重写针对的是方法而不是属性。
- 方法名必须相同
- **参数列表必须相同（**否则变成重载形式！错！）
- 修饰符：范围可以扩大但不能缩小：public > protected > default >private
- 抛出的异常：范围，可以被缩小，但不能扩大。
重写：子类的方法必须和父类的方法一致；方法体不同，返回值类型也要一样。
重写的原因：父类的功能，子类不一定需要，或者不一定满足！
快捷键：Alt + Insert；选择Override，右键同理。
多态
-
多态能实现动态编译：类型，增强可拓展性。
-
多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类、有关系的类）。
-
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
-
注意：多态是方法的多态，属性没有多态性。
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
public void eat() {
System.out.println("eat");
}
}
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
// 一个对象的实际类型是去诶定的
//new Student();
//new Person();
// 可以指向的引用类型就不确定了：父类的引用指向子类
// Student（子类）能调用的方法都是自己的或者继承父类的！
Student s1 = new Student();
// Person（父类）虽然可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
// 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
// s2.run(); // 子类重写了父类的方法，执行子类的方法。
// s1.run();
//s2.eat(); 会报错
s1.eat();
((Student)s2).eat(); // 但是可以强制转换 高转低
}
}
多态注意事项
- 多态是方法的多态，属性没有多态。
- 父类和子类，有联系， 可以转换，但不能乱转换，强行转换会报类型转换异常：ClassCastException！看到这个异常就说明父子类有问题。
- 多态存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
不能被重写的方法：
- static 方法，属于类，它不属于实例
- final 常量；
- private 方法：私有方法不能被重写。
instanceof
instanceof：判断一个对象是什么类型，可以判断两个类之间是否存在父子关系
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person {
}
public class Teacher extends Person {
}
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
// Object > String
// Object > Person > Student
// Object > Person > Teacher
Object object = new Student();
// System.out.println(X instanceof Y); 能不能编译通过！
// 有父子关系编译通过 没有父子关系编译不通过
System.out.println(object instanceof Student); // true
System.out.println(object instanceof Person); // true
System.out.println(object instanceof Object); // true
System.out.println(object instanceof Teacher); // false
System.out.println(object instanceof String); // false
System.out.println("====================");
Person person = new Student();
System.out.println(person instanceof Student); // true
System.out.println(person instanceof Person); // true
System.out.println(person instanceof Object); // true
System.out.println(person instanceof Teacher); // false
// System.out.println(person instanceof String); // 编译报错
System.out.println("====================");
Student student = new Student();
System.out.println(student instanceof Student); // true
System.out.println(student instanceof Person); // true
System.out.println(student instanceof Object); // true
// System.out.println(student instanceof Teacher); // 编译报错
// System.out.println(student instanceof String); // 编译报错
}
}
能不能编译通过取决于有没有父子关系， 有父子关系编译能通过，没有父子关系编译不能通过。
类型转换
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person {
public void go(){
System.out.println("go");
}
}
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//类型之间的转换:基本类型转换 高转换低强制 低转高会自动转 父 —> 子
Person obj = new Student();
// student.go();会报错 因为Person类型没有go方法
//将这个对象转换为Student类 就可以使用Student类的方法了
// Student student = (Student) obj;
// student.go();
((Student) obj).go();
//子类转换为父类 可能会丢失自己本来的一些方法
Student student = new Student();
student.go();
Person person = student;
}
}
类型转换过程需要注意：
- 父类引用指向子类对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型：强制转换
- 方便方法的调用，减少重复的代码，使代码变得更简洁。
抽象三巨头：封装、继承、多态！
抽象：编程思想，要持续的学习，才会茅塞顿开！多实践，多测试想法！实践出真知！
static修饰符
static关键字修饰的变量意为静态变量，可以被类的所有实例共享。
静态变量是通过类名来访问的。
package oop.demo07;
// static
public class Student {
private static int age; // 静态的变量 多线程常用
private double score; // 非静态的变量
public void run() {
go(); // 静态方法可以在非静态方法中调用
}
// 静态方法跟着类一起加载
public static void go() {
}
public static void main(String[] args) {
// run(); 报错
new Student().run(); // 非静态方法要现new对象才能调用
go(); // 静态方法则可以直接调用
Student s1 = new Student();
//静态变量对于类，所有对象所共享，当直接使用类去调用得到，说明这个变量是静态的
System.out.println(Student.age);
// System.out.println(Student.score); 报错，score不是静态变量
System.out.println(s1.age);
System.out.println(s1.score);
}
}
代码块
public class Person {
// 第二个执行，可以用来赋初始值
{
//代码块 （匿名代码块）
System.out.println("匿名代码块");
}
// 第一个执行，和类一起加载，只执行一次
static {
System.out.println("静态代码块");
}
// 第三个执行
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("============");
Person person2 = new Person();
}
}
输出结果：
静态代码块
匿名代码块
构造方法
============
匿名代码块
构造方法
静态导入包与final
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(Math.random()); // 不想每次都写前面的Math.
System.out.println(random()); // 可以直接静态导入包
System.out.println(PI); // 就不用再写了
}
}
final关键字会让一个类断子绝孙，其他的类不能再继承被final修饰的类。
抽象类
- abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
- 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
- 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的，也就是说不能实例化。
- 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
- 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
// abstract 抽象类：类 extends :单继承 （接口可以多继承）
public abstract class Action {
// 约束~有人帮我们实现
// abstrat,抽象方法，只有方法名字，没有方法的实现！
public abstract void doSomething();
// 不能new这个抽象类，只能靠子类去实现它，它只是一种约束！
// 抽象类中可以写普通的方法
// 抽象方法必须在抽象类中~
// 抽象的抽象：约束~
}
// 抽象类的所有方法，继承了他的子类，都必须要实现它的方法~ 除非子类也是abstract
public class A extends Action {
@Override
public void doSomething() {
}
}
import oop.demo08.Action;
public class Application {
public static void main(String[] args) {
// new Action(); 报错，抽象类不能new对象
}
}
抽象类不能new，那么有构造器吗？但是有的，是存在默认的构造器的，可以通过其class文件发现。
存在的意义：抽象出来共有的东西作为模板，提高开发效率。
接口
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有！
- 接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程！
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是……则必须能……”的思想。如果你是天使，则必须能飞等等。
- 接口的本质是契约，就像我们人间的法律一样，制定好后大家都要遵守。
- OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言比如（C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
- 声明类的关键字是class，声明接口的关键字是interface。
public interface TimeService {
void timer();
}
// 抽象的思维~
// interface 定义的关键字，接口都需要有实现类
public interface UserService {
// 接口中定义的属性都是常量 public static final
int AGE = 99;
// 接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
// 抽象类：extends
// 类可以实现接口 通过关键字implements
// 实现了接口的类，就需要重写接口中的方法~
// 多继承~利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
接口的作用
- Java的接口是一个约束
- 定义一些方法，让不同的人实现~
- 接口中的方法都是用public abstract修饰的
- 接口中的常量都是用public static final修饰的，可以直接使用
- 接口不能被实例化，接口中没有构造方法（它都不是类更别提构造方法了）
- 通过implement关键字可以实现多个接口，必须要重写接口中的方法
内部类（不推荐自己乱写）
- 内部类就是在一个类的内部再定义一个类，比如：A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
public class Outer {
// 局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
// 若加上static 变为public static void class Inner后就拿不到id了 此时叫做静态内部类
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
// 获得外部类的私有属性~私有方法都可以
public void getID(){
System.out.println(id);
}
}
}
// 一个java类中可以有多个class类，但是只能有一个public class
// 一般会用来写测试方法
class A{
public static void main(String[] args) {
}
}
public class Test {
public static void main(String[] args) {
// 匿名类
// 没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
// 匿名类
UserService userService = new UserService(){
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
import oop.demo08.Action;
import oop.demo10.Outer;
public class Application {
public static void main(String[] args) {
// new
Outer outer = new Outer();
// 通过这个外部类来实例化内部类~
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}
补充
2023年8月15日补充
以下内容引用自Java 面试指南 | JavaGuide(Java面试 + 学习指南)
构造方法有哪些特点？是否可被 override?
构造方法特点如下：
- 名字与类名相同。
- 没有返回值，但不能用 void 声明构造函数。
- 生成类的对象时自动执行，无需调用。
构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。
著作权归Guide所有 原文链接：Java基础常见面试题总结(中) | JavaGuide(Java面试 + 学习指南)
这里的话，我认为，正是因为构造方法的名字与类名是一样的，所以构造方法是不能被重写的，因为重写的要求是子类重写方法一定和父类方法名字不一样，而构造方法是可以被重载的，因为重载要求是重载方法名字一定和原方法名字一样。
接口和抽象类有什么共同点和区别？
共同点：
- 都不能被实例化。
- 都可以包含抽象方法。
- 都可以有默认实现的方法（Java 8 可以用
default关键字在接口中定义默认方法）。区别：
- 接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。
- 一个类只能继承一个类，但是可以实现多个接口。
- 接口中的成员变量只能是
public static final类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。
著作权归Guide所有 原文链接：Java基础常见面试题总结(中) | JavaGuide(Java面试 + 学习指南)
接口就是一个约束，一个类实现（implement）了某个接口，就就有了这个接口对应的行为约束；接口是规范，定义的是一组规则，实现了这个接口的类就要按照这个接口定义的规则来做出相应的行为。