java学习笔记---3
32.继承中构造方法的访问
1.背景: 创建子类和父类的构造方法时,在测试类中运行
2.特点:
子类中的所有的构造方法都会默认访问父类中的无参构造方法；
why？
1.因为子类会继承父类中的数据，可能还会使用父类中的数据，所以，子类初始化之前，一定要先完成父类数据的初始化；
2.每个子类的构造方法第一条默认语句都是：super（）；
//通过子类访问父类中的带参构造方法：super（参数）；
2022/1/11
“我想回家555555555”
33.继承中成员方法的访问
1.例子
运行结果：
可知：子类继承父类，同时也继承父类中的成员方法，可以直接使用；
例子2：
若子类总有和父类相同的方法
运行结果：
可知：如果子类中有和父类相同的成员方法，这测试类中会优先调用子类的；
例子3：
若子类和父类中有相同的方法，若想同时也调用父类中的方法，则可采用super.方法（）；
运行结果：
34.方法重写
1.是什么？ 子类中出现和父类一模一样的方法声明；
2.应用场景？ 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类的方法，这样既延继了父类的功能，又定义了子类特有的内容；
3.练习：
//比如有一个手机类，它可以实现打电话功能；
//现在出了一款新式手机，它可以在打电话之前开启视频功能；
如下：
新老手机测试如下：
结果：
可知：新老手机又一个相同的方法，不同的是，新手机在这个方法里增加了功能，由于是新增的，我们可以采用重新功能省去新手机里和旧手机相同的代码编写，重新方法 ：super.方法名（参数）；
运行结果：
//一个注解：@Override
检查重写方法的方法声明的正确性；
4.方法重新的注意事项：
//Override报错说明：父类中的私有方法是不能被子类继承，所以子类根本不能重新；
//子类重新父类的时候：访问权限不能比父类低；
（public>默认>private）
35.继承的注意事项
1.java中不可多个继承，一个子类只能继承一个父类；
2.java可以多层继承（比如父亲类继承爷爷类，儿子继承父亲类，这时相当于儿子也继承了爷爷类）
36.继承中的案例
例子1.老师学生类：
//需求：定义老师类和学生类，然后写测试类；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，进行测试；
1.老师类（姓名、年龄、教学）
2.学生类（姓名、年龄、学习）
3.测试类
4.共性抽取父类，定义人类（姓名，年龄）
5.定义老师类，继承人类，给出自己的特有方法：教学；
6.定义学生类，继承人类，给出自己的特有方法：学习；
具体代码和运行结果：用继承的方法定义老师学生类
2022/1/12 每日一问： 陕一刀能不能不画饼了？!
例子2：猫和狗
//需求：采用继承的思想实现猫和狗的案例
1.猫：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠
2.狗：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门
3.共性：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法
具体代码：猫鼠类（继承）
37.导包
使用不同包里的类的方法
1.假如要在family这个包的测试类中调用animal中的dog类
方法：在调用这个类的前边加上包
同理调用Scanner类也可以使用 直接在创建对象处加包名
38.修饰符
一.类： 权限修饰符；状态修饰符；
二.权限修饰符：
java中的四种权限修饰符：
private < 默认 < protected < public；
2.1.测试看在本类中哪些修饰符可以被访问到：
//ans:都可以访问到
package XiuShiFU;
public class Fu { //四种权限修饰符的使用
private void show1(){
System.out.println("private");
}
void show2(){
System.out.println("默认");
}
protected void show3(){
System.out.println("protected");
}
public void show4(){
System.out.println("public");
}
public static void main(String[] args) { //测试看在本类中哪些方法能够使用
Fu f = new Fu();
f.show1();
f.show2();
f.show3();
f.show4();
}
}
测试结果：（都可以访问到）
3.在同一个包下的子类继承父类，看哪些修饰符可以被访问
ans：除private外都可以被访问到
子类：
3.在其他类中可以访问的修饰符
ans：除private外都可以被访问到
4. 不同包下可以访问的修饰符
ans:只能访问public类
小结：
| 修饰符 | 同一个类 | 同一个包子类无关类 | 同一个类非子类 | 不同包的子类 | 不同包的非子类 |
|---|---|---|---|---|---|
| private | 可 | ||||
| 默认 | 可 | 可 | 可 | ||
| protected | 可 | 可 | 可 | 可 | |
| public | 可 | 可 | 可 | 可 | 可 |
三.状态修饰符
1.类： final（最终态）； static（静态）；
2.final类： 可以修饰成员方法，成员变量，类；
2.1特点：
不修饰父类时：
测试结果：
可知：子类可以对父类中的方法进行重写，在测试类中优先访问子类的方法
1.若采用final修饰父类：
可知：
在子类中不能正常重新父类的方法；
这是因为被final修饰的方法是最终方法，最终方法是不可以被重新的；
2.采用final修饰成员变量：
这里可知：在子类中，成员方法对age赋值为20，但在show方法里对age进行了重新赋值结果输出为show方法里的值
3.若对成员变量的age采用final修饰：
可知：final修饰的成员变量不能再次赋值了
4.采用final修饰类：
可知：用final修饰的类是最终类，她不可以再被继承；
5.final修饰局部变量
//f是是引用类型的变量
引用类型的变量用final修饰之后：
why？
因为引用类型采用final后，是把他的地址值变成了最终太，地址不能变但是值可以变；
2022/1/13 距离我考研完已经过去了19天，我曾经无数次幻想过考研结束的美好生活，能够去见想见的人，去向往的城市体验一下不同的生活；结果现在这个疫情，把我又搞回那种三点一线的生活轨迹，我已经半年没出过学校了，我也不想出去玩了 我就想回家了。。
3.static静态修饰符
1.定义： static是静态的意思，可以修饰成员方法，成员变量；
2.应用背景：
现在有一个学生类，包括，姓名、年龄、学校，现在录入学生信息可知除了姓名和年龄，学校的信息都是一样的；
package StaticBianLiang;
public class Student { //学生类
public String name;
public int age;
public String university;
public void show(){
System.out.println(name+" "+age+" "+university);
}
}
package StaticBianLiang;
public class StaticDemo { //测试类
public static void main(String[] args) {
Student s = new Student();
s.name = "龙杰";
s.age = 19;
s.university = "山科大"; //院校信息一样
s.show();
Student ss = new Student();
ss.name = "王名";
ss.age = 22;
ss.university = "山科大"; //院校信息一样
ss.show();
}
}
运行结果：
采用static给成员变量赋值，表示这个变量是共享变量，只需一次赋值
应用背景2（成员方法）
3.特点：
- 被类的所有对象共享；（判断是否使用静态关键字的条件）
- 可以通过类名调用（推荐），也可以通过对象名调用；
- 非静态的成员方法，可以访问：静态的成员变量、非静态成员变量、静态成员方法、非静态成员方法。
- 静态的成员方法，只能访问：静态的成员变量和方法。
39. 多态
1.多态的概述： 同一对象在不同时刻表现出的不同形态；
2.举例： 猫
- 猫可以是猫： 猫 cat = new 猫（）；
- 猫可以是动物： 动物 animal = new 猫（）；
- //也就是说猫在不同时刻表现出不同形态；
3.多态的前提和体现
- 有继承/实现关系；
- 有方法重写；
- 有父类引用指向子类对象；
4.多态中成员的访问特点
Animal a = new Cat();
成员变量：(a.age) 编译看左边，执行看左边；（animal）
成员方法（a.eat()） 编译看左边，执行看右边（cat）
why？ 因为成员方法有重写，成员变量没有；
结果：（父类中的）
5.多态的好处和弊端
- 好处：提高了程序的可扩展性
-
具体体现：定义方法的时候，使用父类作为参数，将来使用的时候，使用具体的子类参与操作 - 弊端：不能使用子类特有的功能
2022/1/15 今天有了新希望了 ，25号解封，其实我最近的状态已经调整好了，疫情当下，如果能回家过年真就挺幸福的了。与其整日骂骂咧咧抱怨还不如踏踏实实学一些东西，在初试成绩出来之前，做好充足准备，拿出准研究生的素养，学习！
6.多态的转型
-
向上转型：
从子到父
父类引用指向子类对象
//把子类的对象赋值给父类的引用 -
向下转型：
从父到子
父类引用转向子类对象
//向下转型：通过向下转型解决了子类访问的弊端：不能访问子类特有功能；
7.案例： 用多态的方法实现猫狗类
2022/1/16
40.抽象类
1.概述： 在java中，一个没有方法体的方法定义为抽象方法，而类中如果有抽象方法，该类就是抽象类。
2.例子
创建一个动物类在动物类中给出吃东西方法
package ChouXiang;
public class Animal {
public void eat(){
System.out.println("动物吃东西！");
}
}
package ChouXiang;
public class AnimalDemo {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
}
}
这样做的弊端：假如有个猫类或者狗类继承动物类，在调用eat方法后，并没有重写eat方法，导致不管什么动物都是吃一样的东西，这样做过于笼统，所以在动物的eat方法内不应该给出具体的实现。
3.抽象类的特点：
- 抽象类里边可以有抽象方法也可以有非抽象方法；
- 一个类里有抽象方法那么这个类必须是抽象类；
- 抽象类里不能直接创建具体对象；
- 抽象类可以参照多态的方法通过子类对象来创建对象；
- 抽象类的子类要么重写父类中的所有抽象方法；
- 抽象类的子类要么也是一个抽象类
package ChouXiang;
public abstract class Animal { //抽象类
public abstract void eat(); //抽象方法
public void sleep(){ //非抽象方法
System.out.println("睡觉");
}
}
package ChouXiang;
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
package ChouXiang;
public abstract class Dog extends Animal{
}
package ChouXiang;
public class AnimalDemo {
public static void main(String[] args) {
// Animal a = new Animal();
// a.eat();
Animal a = new Cat();
a.eat();
a.sleep();
}
}
4.抽象类的成员特点
- 抽象类中可以有常量，也可以有变量；
- 抽象类中可以有抽象方法也可以有非抽象方法；
- 抽象类中可以有构造方法；
public abstract class ChouXiangl {
private int age = 20; //变量
private final String city = "北京"; //常量
public void show(){ //非抽象方法 （提高代码的复用性）
age = 40;
System.out.println(age);
System.out.println(city);
}
public abstract void eat(); //抽象方法
public ChouXiangl() { //构造方法 （抽象类中的构造方法用于子类访问父类数据的初始化）
}
public ChouXiangl(int age) { //带参构造方法
this.age = age;
}
}
案例：猫狗类抽象类版： 猫狗抽象类
2022/1/24
（回家了！！！！ 哈哈哈 我已经在家躺尸好几天了，真开心。）
41.接口
1.接口的概述： 接口是一种公共的规范，只要符号规格标准，大家都可以通用。Java中的接口更多体现在对行为的抽象。
2.接口的特点：
- 接口用关键字interface修饰；
public interface 接口名（）{} - 类实现接口用implements表示（相当于继承）；
public class 类名 implements 接口名{} - 接口不能实例化；
接口可以通过多态的方式，通过实现类对象的实例化，这叫接口的多态。
多态的形式：具体类多态，抽象类多态，接口多态；
多态的实现前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向(子/实现）类对象。 - 接口的实现类： 要么重写接口的所有抽象方法；要么是抽象类；
接口的创建：
关于调高的一个接口类：
package JieKou;
/*
* 定义的一个接口
* */
public interface Jumpping {
public abstract void jump(); //抽象类
}
猫类继承接口类并重写抽象方法：
package JieKou;
public class Cat implements Jumpping{
@Override
public void jump(){
System.out.println("猫跳的老高了！");
}
}
狗类直接定义为抽象类并继承接口：
package JieKou;
public abstract class Dog implements Jumpping{
}
测试类：
package JieKou;
public class JumppingDemon {
public static void main(String[] args) {
//Jumpping jj = new Jumpping(); 说明接口类是抽象类，它不可以创建具体的对象！
Jumpping j = new Cat();
j.jump();
}
}
3.多态的成员特点：
-
成员变量
只能是常量
默认修饰符是：public static final -
构造方法
接口没有构造方法，因为接口主要是对行为进行抽象，是没有具体的存在的；
一个类没有父类，默认继承Object类； -
成员方法：
只能是抽象方法
默认修饰符为：public abstract
接口：
package JieKou;
public interface Inter { //一个接口
//接口中的成员变量
public int num = 20; //变量
public final int num2 = 30; //常量
public static final int num3 = 40; //默认态
}
接口的实现类：
package JieKou;
//public class InterImpGouZao implements Inter{}
public class InterImpGouZao extends Object implements Inter{
public InterImpGouZao(){
super();
}
}
测试类：
package JieKou;
public class InterImpl implements Inter { //接口的实现类
public static void main(String[] args) {
Inter i = new InterImpl();
System.out.println(i.num);
System.out.println(i.num2);
System.out.println(Inter.num3);
}
}
4.案例：猫和狗
//需求：对猫和狗进行训练，他们就可以调高了，在这里加入跳高功能。
采用抽象类和接口实现猫狗案例；
具体代码： 猫狗类（接口）
5.类和接口的关系：
- 类和类的关系：
继承关系：但只能单继承，可以多层继承； - 类和接口关系：
实现关系：可以单实现，也可以多实现，还可以继承一个类的同时实现多个接口； - 接口和接口关系:
继承关系：可以继承，也可以多继承；
6.抽象类和接口的区别：
| 区别 | 抽象类 | 接口类 |
|---|---|---|
| 成员区别 | 变量，常量，构造方法，抽象方法，非抽象方法 | 常量，抽象方法 |
| 关系区别 | 对类抽象，包括属性、行为 | 对行为抽象，主要是行为 |
案例：门和警报案例
//我们知道门可以关和开，实现这个，我们既可以用抽象类也可以用接口
//随着时代的发展，优秀的门还会具有报警功能
//但是：有报警的门又不是人人家里都有，有的人觉得没必要就不买警报门，所以上述的定义方案都是不完美的；
最好的解决方案：将门的开关作为抽象类，报警的作为一个接口，如果有需要报警门就可以让这个类继承抽象类实现接口：
//再次强调：抽象类是对事物的抽象，接口是对行为的抽象；
7.案例（运动员教练）
//需求:我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流,跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类,哪些抽象类,哪些接口，并用代码实现
具体实现及代码：运动员教练（接口）
2022/1/26
42.形参和返回值问题
1.类名作为形参和返回值；
- 方法的形参是类名，其实需要的是该类的对象
- 方法的返回值是类名，其实返回的是该类的对象
package XingCanFanHuiZhi;
public class Cat {
public void eat(){
System.out.println("猫吃鱼");
}
}
package XingCanFanHuiZhi;
public class CatDemo {
public static void main(String[] args) {
CatOperator co = new CatOperator();
Cat c = new Cat();
co.useCat(c);
}
}
package XingCanFanHuiZhi;
public class CatOperator {
public void useCat(Cat c){ //Cat类作为形参
c.eat();
}
}
测试结果：
注意：
2.抽象类名作为形参和返回值
- 方法的形参是抽象类名，其实需要的是该抽象类的子类对象；
- 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象；
3.接口名作为形参和返回值
- 方法的形参是接口名，其实需要的是该接口的实现类对象；
- 方法的返回值是接口名，其实返回的是该接口的实现类对象；
43.内部类
1.概念： 内部类就是在一个类中定义一个类。
eg：在一个类A的内部定义一个B类，B类就成为内部类；
2.格式与范例：
3.内部类的访问特点：
- 内部类可以直接访问外部类的成员，包括私有；
- 外部类要访问内部类的成员，必须创建对象；
package NeiBuiLei;
public class Outer {
private int num = 20;
public class Inter{ //内部类可以直接访问外部类成员包括私有
public void show(){
System.out.println(num);
}
}
public void method(){ //外部类不可以直接访问内部类，必须创建对象
Inter i = new Inter();
i.show();
}
}
4.成员内部类：
1.分类: 按照内部类在类中定义的位置不同，可以分为如下两种形式：
- 在类的成员位置：成员内部类
- 在类的局部位置：局部内部类
- 匿名内部类
2.成员内部类的格式：
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
eg: Outer.Inter oi = new Outer().new Inter();
package NeiBuiLei;
public class Outer {
private int num = 10;
public class Inter{ //成员内部类
public void show(){
System.out.println(num);
}
}
}
package NeiBuiLei;
public class InnerDemo {
public static void main(String[] args) {
//创建内部类对象，调用方法
Outer.Inter oi = new Outer().new Inter();
oi.show();
}
}
//但是我们一般不是这么调用内部类的，我们创建内部类的目的是为了隐藏这个类，并不对外界直接开放；所以一般对于内部类的修饰是private；
package NeiBuiLei;
public class Outer {
private int num = 10;
private class Inter{ //成员内部类
public void show(){
System.out.println(num);
}
}
public void method(){
Inter i = new Inter();
i.show();
}
}
package NeiBuiLei;
public class InnerDemo {
public static void main(String[] args) {
//创建内部类对象，调用方法
Outer o = new Outer();
o.method();
}
}
5.局部内部类
- 局部内部类是在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用
- 该类可以直接访问外部类成员，也可以访问方法内部的局部变量；
package NeiBuiLei;
import JieKou.Inter;
public class Outer {
private int num = 10;
public void method(){
final int num2 = 20;
class Inner{ //局部内部类
public void show(){
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
package NeiBuiLei;
public class InnerDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
6.匿名内部类
1.前提： 存在一个类或者接口，这里的类可以是具体类也可以是抽象类；
2.格式与范例：
3.本质： 匿名内部类的本质实际是一个对象，它继承了该类或者实现了该接口的子类匿名对象
package NiMing;
public interface Inter { //匿名内部类的前提（必须有个接口或者类）
void show(); //默认抽象方法
}
package NiMing;
public class Outer {
public void method(){
new Inter(){ //匿名内部类
@Override
public void show(){
System.out.println("匿名内部类");
}
}.show();
}
}
package NiMing;
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
多次调用， 可以直接对匿名内部类创建对象
4.匿名内部类在开发中的使用
背景 ：我们知道对于一个接口，它不能有具体的方法，一般都是抽象方法，然后在具体的类中实现接口，但是这样的弊端就是，我们需要对每一个具体的对象创建一个类并且去重写接口中的方法，过于繁琐。
匿名内部类 ：因为它的本质就是一个对象，而且是匿名的
package NiMing;
public interface Jumpping { //接口
void jump();
}
package NiMing;
public class JumppingOperator {
public void method(Jumpping j){
j.jump();
}
}
package NiMing;
import java.sql.SQLOutput;
public class JumppingDemo {
public static void main(String[] args) {
JumppingOperator jo = new JumppingOperator();
jo.method(new Jumpping() {
@Override
public void jump() {
System.out.println("猫会调高");
}
});
jo.method(new Jumpping() {
@Override
public void jump() {
System.out.println("狗会调高");
}
});
}
}
运算结果：
2022/1/27
44.常用ApI
学过的：String , StringBuilder;
1.Math :包含执行基本数字运算的方法；
特点：
- 在java.lang包内，使用时不用导包；
- 是最终类被final修饰： public final class Math;
- 继承Object类（所以的类都直接或者间接继承Object类）；
- 没有构造方法，但是可以直接通过类名直接调用；
- 成员方法和成员变量被static关键字修饰；
成员方法
- public static int abs(变量类型 变量): 返回参数的绝对值；
- public static double ceil(double a) : 返回大于等于a的最小double值，相当于一个整数；
- public static double floor(double a): 返回小于等于a的最大double值，相当于一个整数；
- public static int round(float a) : 四舍五入返回最接近参数a的int值；
- public static int max(int a , int b) : 返回两个int值中的较大值；
- public static int min(int a , int b) : 返回两个int值中的较小值；
- public static double pow(double a, double b) :返回a的b次幂；
- public static double random() : 返回值为double的正值，[0.0 ,1.0)
public class MathDemo { //Math常用方法
public static void main(String[] args) {
//绝对值
System.out.println(Math.abs(88)); //88
System.out.println(Math.abs(-88)); //88
System.out.println(Math.abs(-12.36)); //12.36
System.out.println("-------------------------");
//最小/大double
System.out.println(Math.ceil(3.14)); //4.0
System.out.println(Math.floor(3.14)); //3.0
System.out.println("-------------------------");
//四舍五入
System.out.println(Math.round(3.14)); //3
System.out.println(Math.round(3.64)); //4
System.out.println("-------------------------");
//比较大小
System.out.println(Math.max(12,15)); //15
System.out.println(Math.min(12,15)); //12
System.out.println("-------------------------");
//返回幂次方
System.out.println(Math.pow(2.0,3.0)); //8.0
System.out.println("-------------------------");
//返回double正值
System.out.println(Math.random()); //随机一个0.几的小数
System.out.println(Math.random()*100);
}
}
2.System： 终止虚拟机或者返回时间；
特点：
- 在java.lang包内，使用时不用导包；
- 是最终类被final修饰： public final class System;
- 继承Object类;
- 不能被实例化（即：不能创建对象）；
- 成员方法被静态修饰（所以不需要创建对象直接通过类名就可以访问）；
成员方法：
- exit (int static) : 终止当前运行的虚拟机。（参数作为状态代码，非零状态下表示异常终止）；
- currentTimeMillis( ) :返回当前时间距离1970的时间，单位为毫秒；
currentTimeMillis( )的另一个作用：记录程序所运行的时间：
3.Object： 类层次结构的根，没个类都有Object作为超类。所有对象包括数组都实现了这个类的方法；
特点:
- 含有一个无参构造方法：public Object()（构造一个新对象）；
//子类的构造方法默认访问的是父类的无参构造方法，因为他们的顶级父类只有无参构造方法；- 在java.lang包内，使用时不用导包；
- 定义格式：public class Object;
成员方法：
- toString( ): 返回对象的字符串表示；
- equal():
2.示例：
学生类：
package Obj;
public class Student {
private int age;
private String name;
public Student() {
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
测试类：
//看方法源码，选择方法按Ctrl+B
然后无限套娃直到找到
说明：
重写：在Student类里边对toString进行重写
测试结果：
