🌠作者:@TheMyth.
🎇座右铭:不走心的努力都是在敷衍自己,让自己所做的选择,熠熠发光。
目录
👉final关键字👈
【1】修饰变量;
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//第1种情况:
//final修饰一个变量,变量的值不可以改变,这个变量也变成了一个字符常量,约定俗称的规定:名字大写
final int A = 10;//final修饰基本数据类型
//A = 20; 报错:不可以修改值
//第2种情况:
final Dog d = new Dog();//final修饰引用数据类型,那么地址值就不可以改变
//d = new Dog(); -->地址值不可以更改
//d对象的属性依然可以改变:
d.age = 10;
d.weight = 13.7;
//第3种情况:
final Dog d2 = new Dog();
a(d2);
//第4种情况:
b(d2);
}
public static void a(Dog d){
d = new Dog();
}
public static void b(final Dog d){//d被final修饰 ,指向不可以改变
//d = new Dog();
}
}
第3种情况分析图:
第4种情况分析图:
【2】修饰方法;
final修饰方法,那么这个方法不可以被该类的子类重写:
【3】修饰类;
final修饰类,代表没有子类,该类不可以被继承:
一旦一个类被final修饰,那么里面的方法也没有必要用final修饰了(final可以省略不写)
【4】案例:JDK提供的Math类:看源码发现:
(1)使用Math类的时候无需导包,直接使用即可:
(2)Math类没有子类,不能被其他类继承了
(3)里面的属性全部被final修饰,方法也是被final修饰的,只是省略不写了
原因:子类没有必要进行重写。
(4)外界不可以创建对象:
Math m = new Math();
(5)发现Math类中的所有的属性,方法都被static修饰
那么不用创建对象去调用,只能通过类名.属性名 类名.方法名 去调用
👀抽象类和抽象方法
抽象类概念:
在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类.
在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class).
abstract class Shape {
public abstract void draw();
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("♦");
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("●");
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("❀");
}
}
public class Test {
public static void drawMap(Shape shape) {
shape.draw();
}
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
drawMap(new Rect());
drawMap(new Cycle());
drawMap(new Flower());
}
}
【1】抽象类和抽象方法的关系:
抽象类中可以定义0-n个抽象方法。
【2】抽象类作用:
在抽象类中定义抽象方法,目的是为了为子类提供一个通用的模板,子类可以在模板的基础上进行开发,先重写父类的抽象方法,然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性,通过抽象类,子类的设计变得更加严格,进行某些程度上的限制。
使子类更加的通用。
【3】代码:(根据序号进行练习)
//4.一个类中如果有方法是抽象方法,那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
abstract class Person {
//1.在一个类中,会有一类方法,子类对这个方法非常满意,无需重写,直接使用
public void eat(){
System.out.println("一顿不吃饿得慌");
}
//2.在一个类中,会有一类方法,子类对这个方法永远不满意,会对这个方法进行重写。
//3.一个方法的方法体去掉,然后被abstract修饰,那么这个方法就变成了一个抽象方法
public abstract void say();
public abstract void sleep();
}
//6.抽象类可以被其他类继承:
//7.一个类继承一个抽象类,那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰,一般会让子类重写父类中的抽象方法
//9.子类继承抽象类,就必须重写全部的抽象方法
//10.子类如果没有重写父类全部的抽象方法,那么子类也可以变成一个抽象类。
class Student extends Person{
@Override
public void say() {
System.out.println("我是东北人,我喜欢说东北话。。");
}
@Override
public void sleep() {
System.out.println("东北人喜欢睡炕。。");
}
}
public class Demo{
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//11.创建抽象类的对象:-->抽象类不可以创建对象
//Person p = new Person();
//12.创建子类对象:
Student s = new Student();
s.sleep();
s.say();
//13.多态的写法:父类引用指向子类对象:
Person p = new Student();
p.say();
p.sleep();
}
}
总结:
- 抽象类使用abstract修饰类
- 抽象类不能被实例化
- 此时在抽象类中,可以有抽象方法或者非抽象方法
- 什么是抽象方法,一个方法被abstract修饰,没有具体的实现,只要包含抽象方法,这个类一定是抽象类
- 当一个普通类继承了这个抽象类,必须重写抽象类中的抽象方法
- 抽象类最大的意义就是为了被继承
- 抽象方法不能被private,final,static修饰,所以一定要满足方法重写的规则
- 当一个子类没有重写父类的抽象方法,可以把当前子类变为abstract修饰
- 抽象类不一定包含抽象方法,但是有抽象方法的类一定是抽象类
- 抽象类中可以有构造方法,供子类创建对象时,初始化父类的成员变量
抽象类和普通类的区别:
1.抽象类不能实例化,普通类可以
2.抽象类当中,可以包含非抽象方法和抽象方法,但是普通类只能包含非抽象方法
【4】面试题:
(1)抽象类不能创建对象,那么抽象类中是否有构造器?
抽象类中一定有构造器。构造器的作用给子类初始化对象的时候要先super调用父类的构造器。
(2)抽象类是否可以被final修饰?
不能被final修饰,因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了,就不存在继承了,就没有子类。
(3)普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
确实如此. 但是使用抽象类相当于多了一重编译器的校验. 使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成,
而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误,
让我们尽早发现问题. 很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛?
但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们. 充分利用编译器的校验, 在实际开发中是非常有意义的.
✨接口
接口的概念:
在现实生活中,接口的例子比比皆是,比如:笔记本上的USB口,电源插座等。
电脑的USB口上,可以插:U盘、鼠标、键盘...所有符合USB协议的设备 电源插座插孔上,可以插:电脑、电视机、电饭煲...所有符合规范的设备 通过上述例子可以看出:接口就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用。
在Java中,接口可以看成是:多个类的公共规范,是一种引用数据类型。
【1】接口声明格式:
[访问修饰符] interface 接口名 [extends 父接口1,父接口2…] {
常量定义;
方法定义;
}
提示:
1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 "形容词" 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
【2】代码:(根据序号练习)
/**
* 1.类是类,接口是接口,它们是同一层次的概念。
* 2.接口中没有构造器
* 3.接口如何声明:interface
* 4.在JDK1.8之前,接口中只有两部分内容:
* (1)常量:固定修饰符:public static final
* (2)抽象方法:固定修饰符:public abstract
* 注意:修饰符可以省略不写,IDE会帮你自动补全,但是初学者建议写上,防止遗忘。
*/
public interface TestInterface01 {
//常量:
/*public static final*/ int NUM = 10;
//抽象方法:
/*public abstract*/ void a();
/*public abstract*/ void b(int num);
/*public abstract*/ int c(String name);
}
interface TestInterface02{
void e();
void f();
}
/*
5.类和接口的关系是什么? 实现关系 类实现接口:
6.一旦实现一个接口,那么实现类要重写接口中的全部的抽象方法:
7.如果没有全部重写抽象方法,那么这个类可以变成一个抽象类。
8.java只有单继承,java还有多实现
一个类继承其他类,只能直接继承一个父类
但是实现类实现接口的话,可以实现多个接口
9.写法:先继承 再实现:extends Person implements TestInterface01,TestInterface02
*/
class Student extends Person implements TestInterface01,TestInterface02 {
@Override
public void a() {
System.out.println("---1");
}
@Override
public void b(int num) {
System.out.println("---2");
}
@Override
public int c(String name) {
return 100;
}
@Override
public void e() {
System.out.println("---3");
}
@Override
public void f() {
System.out.println("---4");
}
}
class Test{
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//10.接口不能创建对象:
//TestInterface02 t = new TestInterface02();
TestInterface02 t = new Student();//接口指向实现类 ---》多态:向上转型
//11.接口中常量如何访问:
System.out.println(TestInterface01.NUM);//接口名.常量名
System.out.println(Student.NUM);//实现类.常量名
Student s = new Student();
System.out.println(s.NUM);//实现类的对象.常量名
TestInterface01 t2 = new Student();
System.out.println(t2.NUM);
}
}
【3】接口的作用是什么?
定义规则,只是跟抽象类不同地方在哪?它是接口不是类。
接口定义好规则之后,实现类负责实现即可。
【4】
继承:子类对父类的继承
实现:实现类对接口的实现
手机 是不是 照相机
继承:手机 extends 照相机 “is-a”的关系,手机是一个照相机
上面的写法 不好:
实现: 手机 implements 拍照功能 “has-a”的关系,手机具备照相的能力
案例:飞机,小鸟,风筝 (都没有向上抽取的类)
定义一个接口: Flyable
【5】多态的应用场合(重点):
(1)父类当做方法的形参,传入具体的子类的对象
(2)父类当做方法的返回值,返回的是具体的子类的对象
(3)接口当做方法的形参,传入具体的实现类的对象
(4)接口当做方法的返回值,返回的是具体的实现类的对象
【6】接口和抽象类的区别(面试题):
下面接口回答不完整!!!注意JDK1.8新特性!!!
核心区别:
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此,此处的 Animal只能作为一个抽象类, 而不应该成为一个接口.
再次提醒: 抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.
单继承图解:
多实现图解:
JDK1.8以后的接口新增内容
在JDK1.8之前,接口中只有两部分内容:
(1)常量:固定修饰符:public static final
(2)抽象方法:固定修饰符:public abstract
在JDK1.8之后,新增非抽象方法:
(1)被public default修饰的非抽象方法:
注意1:default修饰符必须要加上,否则出错
注意2:实现类中要是想重写接口中的非抽象方法,那么不能加default修饰符,否则出错
public interface TestInterface {
//常量:
public static final int NUM= 10;
//抽象方法:
public abstract void a();
//public default修饰的非抽象方法:
public default void b(){
System.out.println("-------TestInterface---b()-----");
}
}
class Test implements TestInterface{
public void c(){
//用一下接口中的b方法:
b();//如果接口中的b方法没有被重写,那么默认调用接口中的b方法,如果接口中的b方法被重写了,那么调用重写后的b方法
//下面b方法是对接口中的b方法的重写,所以b();调用的是下面重写后的b方法。
//super.b();不可以
TestInterface.super.b();//可以
}
@Override
public void a() {
System.out.println("重写了a方法");
}
@Override
public void b() {//可以重写,也可以不重写
}
}
(2)静态方法:
注意1:static不可以省略不写
注意2:静态方法不能重写
public interface TestInterface2 {
//常量:
public static final int NUM = 10;
//抽象方法:
public abstract void a();
//public default非抽象方法;
public default void b(){
System.out.println("-----TestInterface2---b");
}
//静态方法:
public static void c(){
System.out.println("TestInterface2中的静态方法");
}
}
class Demo implements TestInterface2{
@Override
public void a() {
System.out.println("重写了a方法");
}
public static void c(){
System.out.println("Demo中的静态方法");
}
}
class A {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
Demo d = new Demo();
d.c();//Demo中的静态方法
Demo.c();//Demo中的静态方法(调用静态方法-》类名.方法名(推荐!!!))
TestInterface2.c();//TestInterface2中的静态方法
}
}
疑问:为什么要在接口中加入非抽象方法???
如果接口中只能定义抽象方法的话,那么我要是修改接口中的内容,那么对实现类的影响太大了,所有实现类都会受到影响。
现在在接口中加入非抽象方法,对实现类没有影响,想调用就去调用即可。
图解:
接口练习:
(1)将shape类改为接口实现
/*abstract*/ interface Ishape {
/*public abstract*/ void draw();
public static final int NUM = 10;
/*public default void func() {
System.out.println("JDK8后新增的default修饰的非抽象方法");
}*/
public static void func() {
System.out.println("staticFunc");
}
}
class Rect implements Ishape {
@Override
public void draw() {
System.out.println("♦");
}
/*@Override
public void func() {
System.out.println("重写那个默认方法");
}*/
}
class Flower implements Ishape {
@Override
public void draw() {
System.out.println("❀");
}
}
public class Test {
public static void drawMap(Ishape shape) {
shape.draw();
}
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//Ishape shape = new Ishape();
/*Rect rect = new Rect();
Flower flower = new Flower();*/
Ishape shape = new Rect();//向上转型
Ishape shape2 = new Flower();//向上转型
drawMap(shape);
drawMap(shape2);
Ishape.func();
}
}
(2)请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口:包含打开设备、关闭设备功能
2. 笔记本类:包含开机功能、关机功能、使用USB设备功能
3. 鼠标类:实现USB接口,并具备点击功能
4. 键盘类:实现USB接口,并具备输入功能
public interface IUSB {
void openDevice();
void closeDevice();
}
public class Mouse implements IUSB {
@Override
public void openDevice() {
System.out.println("打开鼠标服务!");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标服务!");
}
public void click() {
System.out.println("点击鼠标!");
}
}
public class KeyBoard implements IUSB {
@Override
public void openDevice() {
System.out.println("打开键盘!");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘!");
}
public void inPut() {
System.out.println("键盘输入!");
}
}
public class Computer {
public void open() {
System.out.println("开机!");
}
public void close() {
System.out.println("关机!");
}
//所有的USB设备在电脑上都可以在电脑上使用
public void useDevice(IUSB usb) {//IUSB usb = new Mouse();向上转型 接口当做方法的形参,传入具体的实现类的对象
usb.openDevice();
if (usb instanceof Mouse) {//usb是不是Mouse类的一个实例
//向下转型
Mouse mouse = (Mouse) usb;
mouse.click();
//((Mouse) usb).click();
} else if (usb instanceof KeyBoard) {
KeyBoard keyBoard = (KeyBoard) usb;
keyBoard.inPut();
//((KeyBoard) usb).inPut();
}
usb.closeDevice();
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
Computer computer = new Computer();
/*Mouse mouse = new Mouse();
KeyBoard keyBoard = new KeyBoard();
computer.useDevice(mouse);
computer.useDevice(keyBoard);*/
/*IUSB mouseNew = new Mouse();
IUSB keyBoardNew = new KeyBoard();
computer.useDevice(mouseNew);
computer.useDevice(keyBoardNew);*/
computer.open();
computer.useDevice(new Mouse());
System.out.println("======");
computer.useDevice(new KeyBoard());
computer.close();
}
}
总结:
- 使用关键字interface来定义接口
- 接口不能被实例化
- 接口当中的成员默认是public static final修饰的
- 接口当中的方法默认是public abstract修饰的
- 接口当中的方法,不能有具体的实现,但从JDK8开始,可以写一个default修饰的方法
- 接口当中不能有构造方法
- 接口需要被类实现,使用关键字implements
- 接口当中可以有static修饰的方法
- 接口中不能有静态代码块和构造方法
- 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class
- 先继承再实现
- 接口可以通过extends 拓展多个接口的功能
接口进阶(重点)
实现多个接口:
在Java中,类和类之间是单继承的,一个类只能有一个父类,
即Java中不支持多继承,但是一个类可以实现多个接口。
abstract class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
/*此时不能把run写这里面,因为不是所有的动物都可以跑
public void run() {
System.out.println("跑!");
}*/
}
/*class A {
public void run() {
System.out.println("跑!");
}
}*/
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
interface IFlying {
void fly();
}
class Dog extends Animal/*, A*/ implements IRunning { //java中只能单继承,所以引出了接口,让跑这个方法用接口来写
public Dog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(name + "正在用四条腿跑");
}
}
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(name + "正在用尾巴游泳");
}
}
class Bird extends Animal implements IFlying {
public Bird(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(name + "正在用翅膀飞");
}
}
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(name + "正在蹬腿游泳");
}
}
class Duck extends Animal implements IRunning, IFlying, ISwimming {
public Duck(String name) {
super(name);
}
@Override
public void run() {
System.out.println(name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(name + "正在飘在水上");
}
@Override
public void fly() {
System.out.println(name + "正在用翅膀飞");
}
}
class Robot implements IRunning {
private String name;
public Robot(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(this.name + "正在用轮子跑");
}
}
public class Test {
/**
* 一定是一个动物,这样写不灵活
*
* @param animal
*/
public static void func(Animal animal) {
}
/**
* 只要实现了 IRunning 接口的 都可以接受
*
* @param iRunning
*/
public static void walk(IRunning iRunning) {
iRunning.run();
}
public static void swim(ISwimming iSwimming) {
iSwimming.swim();
}
public static void fly(IFlying iFlying) {
iFlying.fly();
}
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
walk(new Dog("旺财"));
walk(new Frog("青蛙"));
walk(new Duck("唐老鸭"));
walk(new Robot("机器人"));
System.out.println("===================");
swim(new Fish("小甲鱼"));
swim(new Frog("青蛙2号"));
swim(new Duck("唐老鸭2号"));
System.out.println("===================");
fly(new Bird("小鸟"));
fly(new Bird("唐老鸭3号"));
}
}
上面的代码展示了 Java 面向对象编程中最常见的用法:
一个类继承一个父类, 同时实现多种接口.
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .
猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞 这样设计有什么好处呢?
时刻牢记多态的好处, 让程序猿忘记类型.
有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.
甚至参数可以不是 "动物", 只要会跑,例如传参传入机器人,机器人可以跑。
接口间的继承:
在Java中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承。
即:用接口可以达到 多继承的目的。 接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.
interface A {
void funcA();
}
interface B {
void funcB();
}
interface CC extends A, B {
void func();
}
class C implements CC {
@Override
public void funcA() {
}
@Override
public void funcB() {
}
@Override
public void func() {
}
}
修改Animal类(用接口间的继承):
abstract class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
interface IFlying {
void fly();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
void bark();
}
class Dog extends Animal implements IRunning { //java中只能单继承,所以引出了接口,让跑这个方法用接口来写
public Dog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(name + "正在用四条腿跑");
}
}
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(name + "正在用尾巴游泳");
}
}
class Bird extends Animal implements IFlying {
public Bird(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(name + "正在用翅膀飞");
}
}
class Frog extends Animal implements IAmphibious {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(name + "正在蹬腿游泳");
}
@Override
public void bark() {
System.out.println(name + "正在呱呱叫");
}
}
class Duck extends Animal implements IAmphibious, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void run() {
System.out.println(name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(name + "正在飘在水上");
}
@Override
public void fly() {
System.out.println(name + "正在用翅膀飞");
}
@Override
public void bark() {
System.out.println(name + "嘎嘎嘎的叫");
}
}
class Robot implements IRunning {
private String name;
public Robot(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(this.name + "正在用轮子跑");
}
}
public class Test {
public static void bark(IAmphibious iAmphibious) {
iAmphibious.bark();
}
public static void walk(IRunning iRunning) {
iRunning.run();
}
public static void swim(ISwimming iSwimming) {
iSwimming.swim();
}
public static void fly(IFlying iFlying) {
iFlying.fly();
}
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
walk(new Dog("旺财"));
walk(new Frog("青蛙"));
walk(new Duck("唐老鸭"));
walk(new Robot("机器人"));
System.out.println("===================");
swim(new Fish("小甲鱼"));
swim(new Frog("青蛙2号"));
swim(new Duck("唐老鸭2号"));
System.out.println("===================");
fly(new Bird("小鸟"));
fly(new Bird("唐老鸭3号"));
System.out.println("===================");
bark(new Frog("青蛙3号"));
bark(new Duck("唐老鸭4号"));
}
}
通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.接口间的继承相当于把多个接口合并在一起.
接口使用实例:给对象数组排序
import java.util.Arrays;
class Student {
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("themyth", 19, 80);
students[1] = new Student("wangsheng", 22, 99);
students[2] = new Student("luoyadan", 21, 85);
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
异常原因:学生类不能转换为接口
点进源码:
仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确.
而两个学生对象的大小关系 怎么确定?
需要我们额外指定. 让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法
修改代码:
import java.util.Arrays;
class Student implements Comparable<Student> {
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
/*
写比较规则
*/
/*@Override
public int compareTo(Student o) {//按年龄从小到大排序
*//*if (this.age > o.age) {
return 1;
} else if (this.age < o.age) {
return -1;
} else {
return 0;
}*//*
return this.age - o.age; //return this.age - o.age;
}*/
@Override
public int compareTo(Student o) {//按照姓名从小到大排序
if (this.name.compareTo(o.name) > 0) {//调用的是String类的方法,注意:equals只能判断相不相等
return 1;
} else if (this.name.compareTo(o.name) < 0) {
return -1;
} else {
return 0;
}
}
}
public class Test {
public static void sort(Comparable[] array) {//传入Student数组,类型匹配
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j].compareTo(array[j + 1]) > 0) {
Comparable tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
}
}
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("themyth", 19, 80);
students[1] = new Student("wangsheng", 22, 99);
students[2] = new Student("luoyadan", 21, 85);
//System.out.println(students[0].compareTo(students[1]));
//Arrays.sort(students);
sort(students);
System.out.println(Arrays.toString(students));
}
}
上面的实现很不灵活,我们只能把代码写死,每次比较不同的属性,得重写整个compareTo方法,
接下来引出更灵活的写法,写一个比较器comparator
import java.util.Arrays;
import java.util.Comparator;
class Student {
public String name;
public int age;
public int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
class AgeComparator implements Comparator<Student> {//比较的是Student
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
class ScoreComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.score - o2.score;
}
}
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);//String实现了Comparable接口,重写了compareTo方法
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("themyth", 19, 80);
students[1] = new Student("wangsheng", 22, 99);
students[2] = new Student("luoyadan", 21, 85);
//比较器
AgeComparator ageComparator = new AgeComparator();
ScoreComparator scoreComparator = new ScoreComparator();
NameComparator nameComparator = new NameComparator();
Arrays.sort(students, nameComparator);
System.out.println(Arrays.toString(students));
}
}
OJ练习:
import java.util.Arrays;
import java.util.Scanner;
class PersonSortable implements Comparable<PersonSortable> { //comparable类型为PersonSortable类型的
private String name;
private int age;
public PersonSortable() {
this.name = name;
this.age = age;
}
public PersonSortable(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(PersonSortable o) {
/*if (this.name.compareTo(o.name) > 0) {//调用的是String类的方法,注意:equals只能判断相不相等
return 1;
} else if (this.name.compareTo(o.name) < 0) {
return -1;
} else {
//姓名相同,再按照年龄从小到大排序
return this.age - o.age;
}*/
//优化写法:
if (this.name.equals(o.name)) {//姓名相同,按照年龄从小到大排序
return this.age - o.age;
}
//姓名不相同,按照姓名排序
return this.name.compareTo(o.name);
}
@Override
public String toString() {
return name + "-" + age;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
PersonSortable[] personSortables = new PersonSortable[n];
for (int i = 0; i < personSortables.length; i++) {
String name = sc.next();
int age = sc.nextInt();
personSortables[i] = new PersonSortable(name, age);
}
Arrays.sort(personSortables);
for (int i = 0; i < personSortables.length; i++) {
System.out.println(personSortables[i]);
}
}
}
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
class PersonSortable2 {
private String name;
private int age;
public PersonSortable2() {
this.name = name;
this.age = age;
}
public PersonSortable2(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return name + "-" + age;
}
}
class AgeComparator implements Comparator<PersonSortable2> {
@Override
public int compare(PersonSortable2 o1, PersonSortable2 o2) {
return o1.getAge() - o2.getAge();
}
}
class NameComparator implements Comparator<PersonSortable2> {
@Override
public int compare(PersonSortable2 o1, PersonSortable2 o2) {
return o2.getName().compareTo(o1.getName());//降序
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
PersonSortable2[] personSortables = new PersonSortable2[n];
for (int i = 0; i < personSortables.length; i++) {
String name = sc.next();
int age = sc.nextInt();
personSortables[i] = new PersonSortable2(name, age);
}
AgeComparator ageComparator = new AgeComparator();
NameComparator nameComparator = new NameComparator();
Arrays.sort(personSortables, nameComparator);
System.out.println("NameComparator:sort");
for (int i = 0; i < personSortables.length; i++) {
System.out.println(personSortables[i]);
}
System.out.println("AgeComparator:sort");
Arrays.sort(personSortables, ageComparator);
for (int i = 0; i < personSortables.length; i++) {
System.out.println(personSortables[i]);
}
}
}
Clonable 接口和深拷贝
Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要 先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.
空接口-》标记接口:作用就是表示当前对象是可以被克隆的
对自定义类型进行拷贝:
class Student implements Cloneable {
public String name;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) throws CloneNotSupportedException {
Student student1 = new Student();
student1.name = "themyth";
/*Object clone = student1.clone();
Student student2 = (Student)clone;*/
//这儿没有用instanceof是因为所有类的父类一定是Object,不会是其它的类
Student student2 = (Student) student1.clone();//因为clone方法返回值是Object父类,这儿要向下转型
System.out.println(student1);
System.out.println(student2);
}
}
再谈深拷贝和浅拷贝:
浅拷贝:
class Money {
public double money = 12.25;
}
class Student implements Cloneable {
public String name;
public Money m = new Money();
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) throws CloneNotSupportedException {
Student student1 = new Student();
Student student2 = (Student) student1.clone();
System.out.println(student1.m.money);
System.out.println(student2.m.money);
System.out.println("======");
student2.m.money = 99;
System.out.println(student1.m.money);
System.out.println(student2.m.money);
}
}
内存分析:
深拷贝:
class Money implements Cloneable{
public double money = 12.25;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student implements Cloneable {
public String name;
public Money m = new Money();
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
//只是克隆了Student对象
Student student = (Student) super.clone();
//克隆了 Student对象里面的Money对象
student.m = (Money) this.m.clone();//将student1所指向的m对象克隆一份
return student;
//return super.clone();
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) throws CloneNotSupportedException {
Student student1 = new Student();
Student student2 = (Student) student1.clone();
System.out.println(student1.m.money);
System.out.println(student2.m.money);
System.out.println("======");
student2.m.money = 99;
System.out.println(student1.m.money);
System.out.println(student2.m.money);
}
}
内存分析:
再次强调:深拷贝和浅拷贝只跟代码的实现有关系!!!
🌟内部类
当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服 务,那么这个内部的完整结构最好使用内部类。在 Java 中,可以将一个类定义在另一个类或者一个方法的内部, 前者称为内部类,后者称为外部类。内部类也是封装的一种体现。
public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类
【注意事项】
1. 定义在class 类名{}花括号外部的,即使是在一个文件里,都不能称为内部类
public class A{
}
class B{
}
// A 和 B是两个独立的类,彼此之前没有关系
2. 内部类和外部类共用同一个java源文件,但是经过编译之后,内部类会形成单独的字节码文件
成员内部类
根据序号进行练习:
/**
*1.类的组成:属性,方法,构造器,代码块(普通块,静态块,构造块,同步块),内部类
*2.一个类TestOuter的内部的类SubTest叫内部类
*3.内部类:成员内部类(静态的,非静态的) 和 局部内部类(位置:方法内,代码块内,构造器内)
*4.成员内部类:
* 里面属性,方法,构造器等
* 修饰符:private default protect public final abstract
*/
public class TestOuter {
//成员内部类:
//one_非静态的成员内部类
public class D{
int age = 20;
String name ="ws";
public void method(){
//5.内部类可以访问外部类的内容
/* System.out.println(age);
a();*/
int age = 30;
//8.内部类和外部类属性重名的时候,如何进行调用:
System.out.println(age);//30
System.out.println(this.age);//20
System.out.println(TestOuter.this.age);//10
}
}
//two_静态成员内部类:
static class E{
public void method(){
//6.静态内部类中只能访问外部类中被static修饰的内容,如果确实要访问其它内容,得创建对象
/*System.out.println(age);
a();*/
//即:当外部类的属性age和a方法都被static修饰后才能成功运行上面的代码
}
}
//属性:
int age = 10;
//方法:
public void a(){
System.out.println("这是a方法");
{
System.out.println("这是一个普通块");
class B{//局部内部类(普通块内)
}
}
class A{//局部内部类(方法内)
}
//7.外部类想要访问内部类的东西,需要创建内部类的对象然后进行调用
D d = new D();
System.out.println(d.name);
d.method();
}
static{
System.out.println("这是静态块");
}
{
System.out.println("这是构造块");
}
//构造器:
public TestOuter(){
class c{//局部内部类(构造器内)
}
}
public TestOuter(int age){
this.age=age;
}
}
class Demo {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//创建外部类的对象:
TestOuter to = new TestOuter();
to.a();
//9.创建内部类的对象:
//静态的成员内部类创建对象:
TestOuter.E e = new TestOuter.E();//外部类名.内部类名
//非静态的成员内部类创建对象:
//错误:TestOuter.D d = new TestOuter.D();
TestOuter t = new TestOuter();
TestOuter.D d = t.new D();
}
}
静态内部类练习:
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类
static class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void func() {
System.out.println("static->InnerClass::func()");
/*2.在静态内部类中,不能直接访问外部类的非静态成员
但是可以通过创建外部类对象,再访问它的
System.out.println(data1);
System.out.println(data2);
*/
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.data1);
System.out.println(outerClass.data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
public void test() {
InnerClass innerClass = new InnerClass();
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(innerClass.data4);
System.out.println(innerClass.data5);//3.外部类 可以访问静态内部内当中的所有成员
System.out.println(InnerClass.data6);//静态的成员变量,直接类名.
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//InnerClass innerClass = new InnerClass();1.静态内部类不能直接通过类名创建对象,创建静态内部类对象时,不需要先创建外部类对象
OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
innerClass.func();
System.out.println("-----------");
OuterClass outerClass = new OuterClass();
outerClass.test();
}
}
非静态内部类练习:
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//非静态内部类
class InnerClass {
public int data1 = 142857;
public int data4 = 4;
private int data5 = 5;
/*
1.在非静态内部类中不能直接定义静态成员变量
因为内部类是依赖于外部类才创建的,而static修饰的变量不依赖于对象的,产生矛盾
相当于此时外部类加载到时候,这个非静态内部类不会加载
如果实在是要定义需要加上final关键字
常量是在程序编译时候就已经确定了
*/
public static final int data6 = 6;
public void func() {
System.out.println("InnerClass::func()");
//3.内部类和外部类属性重名的时候,如何进行调用:
System.out.println(data1);//142857
System.out.println(this.data1);//142857
System.out.println("====");
System.out.println(OuterClass.this.data1);//1
System.out.println(data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
public void test() {
InnerClass innerClass = new InnerClass();
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(innerClass.data4);
System.out.println(innerClass.data5);
System.out.println(InnerClass.data6);//访问静态成员,直接类名.
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
/*
2.非静态内部类也不能直接通过类名创建对象
需要先创建外部类对象,再创建
注意:
静态内部类是不需要先创建外部类对象的
而非静态内部类需要先创建外部类对象,再进行创建
*/
//InnerClass innerClass = new InnerClass();
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.func();
}
}
局部内部类
public class TestOuter {
//1.在局部内部类中访问到的变量必须是被final修饰的
public void method(){
final int num = 10;
class A{//局部内部类(方法内中的类)
public void a(){
//num = 20;
System.out.println(num);
}
}
}
//2.如果类B在整个项目中只使用一次,那么就没有必要单独创建一个B类,使用内部类就可以了
//方法结束,类也被销毁了
public Comparable method2(){//用接口当作方法的返回值,返回的是具体的实现类的对象
class B implements Comparable{
@Override
public int compareTo(Object o) {
return 100;
}
}
return new B();
}
public Comparable method3(){
//3.匿名内部类(安卓用得比较多)
return new Comparable() {
@Override
public int compareTo(Object o) {
return 200;
}
};
}
public void test(){
Comparable com = new Comparable() {//相当于接口=具体的一个实现类
@Override
public int compareTo(Object o) {
return 200;
}
};
System.out.println(com.compareTo("abc"));
}
}
局部内部类练习:
class OuterClass {
public void func() {
class InnerClass {
public int a = 1;
public void test() {
System.out.println("InnerClass->test()");
}
}
InnerClass innerClass = new InnerClass();
innerClass.test();
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.func();
}
}
匿名内部类练习:
interface IA {
void func();
}
class AA implements IA {
@Override
public void func() {
System.out.println("hello!");
}
}
public class Test {
//这是一个main方法,是程序的入口:
public static void main(String[] args) {
//方法1:
IA ia1 = new AA();
ia1.func();
//方法2:匿名内部类 new IA() {};
new IA() {
@Override
public void func() {
System.out.println("我去,还可以这样写!");
}
}.func();
}
}
【注意事项】
1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件,命名格式:外部类名字$数字内部类名字.class
4. 几乎不会使用