java第十天学习笔记
回顾：
//static:静态的，可以修饰成员变量，成员方法。修饰成员变量,此变量就为共享，被该类的所有对象所共享。
//静态方法中，只能访问静态的。静态是随着类的加载而加载，优先于对象存在，在静态方法中 ，不能存在this关键字。
//静态修饰的成员，属于类，推荐使用类名调用。
##成员变量和静态变量的区别。
//成员变量属于对象，称之为 实例变量，对象变量，随着对象的创建而存在，随着对象的销毁而销毁
//静态变量属于类，称之为类变量，随着类的加载而加载，随着类的卸载而卸载。
//成员变量存在堆内存，静态变量存在方法区的静态区。
//成员变量，使用对象调用。静态变量使用类名调用。(当然可以使用对象调用，但不推荐。)
//代码块：局部代码块，构造代码块，静态代码块一、继承
继承的引入和概述(掌握)
A:继承概述(就是把多个事物的共性部分，向上抽取到父类当中，以实现代码的复用性和维护性)
a.继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
b.继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使 得子类具有父类相同的行为。
c.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
继承:父辈的财产，子代可以继承。
//Java中的继承，父类的成员，子类可以继承使用。
//要类和类具有父子关系，可以使用 extends 来实现。
//继承可以提高代码的复用性和维护性。
B:继承格式
通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。继承案例演示以及继承的好处和弊端(掌握)
A:需求： 学生类和老师类。
定义两个功能(吃饭，睡觉)
B:案例演示 使用继承前
C:案例演示 使用继承后
D:继承的好处 a:提高了代码的复用性
b:提高了代码的维护性
c:让类与类之间产生了关系，是多态的前提
E:继承的弊端:类的耦合性增强了。
//不好之处：让类和类之间产生了父子关系，增加了耦合性。
开发的原则：高内聚，低耦合。
耦合：类与类的关系(完成一个功能，要去依赖别的类 类跟类之间产生了关系。)
内聚：就是自己完成某件事情的能力(一个类独立完成某些功能的能力)Java中类的继承特点(掌握)
A:Java中类的继承特点
a:Java只支持单继承，不支持多继承。(一个类，只能有一个父类。一个父类，当然可以有多个子类。)
有些语言是支持多继承，格式：extends 类1,类2,...(Java中也支持多层继承 自己--父亲---父亲)
b:Java支持多层继承(继承体系)
B:案例演示
Java中类的继承特点继承的注意事项和什么时候使用继承(掌握)
A:继承的注意事项
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
( 父类的私有成员，子类不能继承。)
b:子类不能继承父类的构造方法，但是可以通过super(待会儿讲)关键字去访问父类构造方法。
(构造方法不参与继承)
c:不要为了部分功能而去继承
B:什么时候使用继承
继承其实体现的是一种关系："is a" .
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。继承中成员变量的关系(掌握)
A:子类中的成员变量和父类中的成员变量名称不一样
B:子类中的成员变量和父类中的成员变量名称一样
在子类中访问一个变量的查找顺序("就近原则")
a: 在子类的方法的局部范围找,有就使用
b: 在子类的成员范围找,有就使用
c: 在父类的成员范围找,有就使用
d:如果还找不到,就报错this和super的区别和应用(掌握)
A:通过问题引出super
//super：表示的是父类的空间标识，你可以理解为父类的一个引用，或者说是对象。
//我们就可以使用super这个关键字，去访问父类的数据
子类局部范围访问父类成员变量
B:说说this和super的区别
this 代表的是本类对象的引用
super代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
C:this和super的使用
a:调用成员变量
this.成员变量名 调用(访问)本类的成员变量
super.成员变量名 调用(访问)父类的成员变量
b:调用构造方法
this(...) 调用(访问)本类的构造方法
super(...) 调用(访问)父类的构造方法
c:调用成员方法
this.成员方法名 调用(访问)本类的成员方法
super.成员方法名 调用(访问)父类的成员方法
注意：b，c马上讲继承中构造方法的关系(掌握)
A:案例演示
子类中所有的构造方法默认都会访问父类中空参数的构造方法。
(当我在创建子类对象时，为什么回先去去调用父类的构造方法？)
B:为什么呢?
因为有了继承关系后，子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
* 如果说这个时候，父类的数据并没有完成初始化，你子类怎么用
* 所以，我们在创建子类对象的时候，就会先调用父类的构造方法，来完成父类数据的初始化，然后在初始化自己的数据。
我们在什么时候，去调用的父类构造呢？
//在每个类的构造方法中的第一行有一行默认代码 super() 这行代码就去调用了父类的空参构造。
//在Java中有一个顶层 父类 Object 这个类就是老祖宗类，所有的类，都是直接或间接继承自他。
其实：
每一个构造方法的第一条语句默认都是：super()
在这里简单的提一句，Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。继承中构造方法的注意事项(掌握)
A:案例演示
父类没有无参构造方法,子类怎么办?
a: 在父类中添加一个无参的构造方法
b:子类通过super去显示调用父类其他的带参的构造方法
c:子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造
B:注意事项
super(…)或者this(….)必须出现在构造方法的第一条语句上继承中的面试题(掌握)
A:案例演示
看程序写结果1
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");}
public void show(){
int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(super.num);//10 }
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show(); }
}
B:案例演示
看程序写结果2
class Fu {
static {System.out.println("静态代码块Fu"); } //1
{System.out.println("构造代码块Fu"); } //3
public Fu() {System.out.println("构造方法Fu"); } //4
}
class Zi extends Fu {
static {System.out.println("静态代码块Zi"); } //2
{System.out.println("构造代码块Zi"); } //5
public Zi() {
super();
System.out.println("构造方法Zi"); } //6
}
class Test{
public static void main(String[] args){
Zi z = new Zi(); //请执行结果。Fu.class--先进内存加载 }
}继承中成员方法关系(掌握)
A:案例演示
a:当子类的方法名和父类的方法名不一样的时候
b:当子类的方法名和父类的方法名一样的时候
通过子类调用方法:
a: 先查找子类中有没有该方法,如果有就使用
b:在看父类中有没有该方法,有就使用
c: 如果没有就报错二、方法重写概述及其应用(掌握)
A:什么是方法重写
子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，就会发生方法覆盖现象，也被称为方法覆盖，方法重写。
//子类方法会覆盖父类方法。
为什么要有方法重写？
//子类对父类的功能实现，并不是很满意，子类想要改写掉父类的功能，或者说想要扩展父类的功能。那么子类都可以使用方法重写来完成。子类就可以去覆盖父类功能的实现，子类可以写一个和父类一模一样的方法（方法名。参数，返回值）
B: Override和Overload的区别?Overload能改变返回值类型吗?
//ctrl+O 重写父类的方法
@Override //注解 可以检测该方法，是否是重写父类的方法
C:方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
D:案例演示
a:定义一个手机类。
b:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。public class Phone {
public void call(){ System.out.println("打电话"); }
public void sendMsg(){ System.out.println("发短信"); }
}
public class Iphone extends Phone{
//ctrl+O 重写父类的方法
@Override //注解 可以检测该方法，是否是重写父类的方法
public void call() {System.out.println("视频打电话"); }
}
public class XiaoMi extends Phone{
@Override
public void call() {
//我还想要保留，父类的功能，还要再此基础上进行扩展
super.call();//沿袭父类的功能
System.out.println("视频聊天");
System.out.println("语音聊天"); }
@Override
public void sendMsg() {
//super.sendMsg();
System.out.println("发彩信"); }
}
public class MyTest {
public static void main(String[] args) {
Iphone iphone = new Iphone();
iphone.call();
System.out.println("==================");
XiaoMi xiaoMi = new XiaoMi();
xiaoMi.call();
xiaoMi.sendMsg(); }
}方法重写的注意事项(掌握)
A:方法重写注意事项
a:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承，何谈重写。
b:子类重写父类方法时，方法前面的权限修饰符，不能比父类方法的权限修饰符的低。可以比父类的高，也可以一样
最好就一致 //public>protected>缺省的>private
c:父类静态方法，子类也必须通过静态方法进行重写。(静态方法，不参与重写)
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
B:案例演示
方法重写注意事项继承案例(掌握)
A:案例演示: 使用继承前的学生和老师案例A:案例演示: 使用继承后的学生和老师案例A:猫狗案例分析，实现及测试
父类的由来: 首先我们需要分析具体的事物,分析完毕以后将共性的内容提取出来放在一个独立的类中(父类).
B:案例演示
猫狗案例继承版public class Person {
String name;
int age;
public void eat() {System.out.println("吃饭"); }
public void sleep() {System.out.println("睡觉"); }
}
public class Teacher extends Person{
@Override
public void eat() {System.out.println("老师爱吃燃面");}
@Override
public void sleep() {System.out.println("老师喜欢按点睡觉");}
public void teach(){System.out.println("老师教书");}
}
public class Student extends Person{
@Override
public void eat() {System.out.println("学生爱吃麻辣烫");}
@Override
public void sleep() {System.out.println("学生喜欢睡到自然醒");}
public void playGame(){System.out.println("学生玩游戏");}
}
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.name = "张三";
student.age = 24;
System.out.println(student.name);
System.out.println(student.age);
student.eat();
student.sleep();
student.playGame();
System.out.println("===========================");
Teacher teacher = new Teacher();
teacher.name = "沈员外";
teacher.age = 18;
System.out.println(teacher.name);
System.out.println(teacher.age);
teacher.eat();
teacher.sleep();
teacher.teach();
}
}三、final关键字概述(掌握)
A:为什么会有final
由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final
B:final概述
final关键字是最终的意思，可以修饰类，变量，成员方法。final关键字修饰类,方法以及变量的特点(掌握)
A:final修饰特点
修饰类: 被修饰类不能被继承
修饰方法: 被修饰的方法不能被重写
修饰变量: 被修饰的变量不能被重新赋值,因为这个量其实是一个常量（此变量为一个常量）
B:案例演示
final修饰特点final关键字修饰局部变量(掌握)
A:案例演示
基本类型，是值不能被改变
引用类型，是地址值不能被改变public class MyTest {
//公共的静态常量
public static final boolean B=true;
public static void main(String[] args) {
//final 最终的，可以修饰变量，可以修饰成员方法，可以修饰类
//final 修饰变量，此变量为一个常量
//常量名一般大写
final int num=100;
// num=200; //报错
System.out.println(num);
final double A=3.14; //自定义常量
System.out.println(MyTest.B);
//final 修饰类，此类不能被继承。
//final 修饰方法。此方法不能被重写，子类只能继承使用。
Son son = new Son();
son.show();
son.test();
System.out.println("========================");
final Son son1 = new Son();
// son1=new Son();
//final 修饰引用类型，指的是 地址值不能再次改变
}
}
//final 修饰类，此类不能被继承。
final class Fu{ }
class Father{
public void show(){}
public final void test(){
System.out.println("最终的方法。子类继承下来使用，子类不能重写");
}
}
class Son extends Father{
@Override
public void show() {
super.show();
}
}四、多态的概述及其代码体现(掌握)
A:多态概述
某一个事物，在不同时刻表现出来的不同状态。
举例： Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
B:多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();
C:案例演示
代码体现多态多态中的成员访问特点(掌握)
A:多态中的成员访问特点
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)
B:案例演示
多态中的成员访问特点多态的好处(理解)
A:多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
B:案例演示
多态的好处
D:案例演示
多态的弊端多态的弊端以及多态中向上转型和向下转型(掌握)
A:通过多态的弊端引出问题
不能使用子类特有的功能
B:解决问题
a:把父类的引用强制转换为子类的引用。(向下转型)
C:案例演示
详细讲解多态中向上转型和向下转型public class MyTest {
public static void main(String[] args) {
//多态的弊端：不能直接调用子类特有的功能
Fu fu = new Zi();
fu.show();
//多态的形式不能调用子类特有的功能
//fu.method();
//如果要调用子类特有的方法，我们可以向下转型。
Zi zi= (Zi) fu;
zi.method();
//向上转型：把子类型，转换成父类型。多态就是向上转型。
}
}
class Fu{
public void show(){
System.out.println("父类的show方法");}
}
class Zi extends Fu{
@Override
public void show() {
System.out.println("我重写了父类的show方法");}
public void method(){
System.out.println("这是子类特有的一个方法");}
}案例演示 孔子装爹
public class MyTest {
public static void main(String[] args) {
//09.05_ 案例演示 孔子装爹
/* 孔子爹，他是一名Java讲师，讲课很有名。一天张三慕名前来，把孔子爹请到家里讲Java去了。
家里就剩孔子一个人在家玩游戏，这个李四，也想学Java,也来请孔子爹，孔子爹不在家，孔子不想失去这个学员。
孔子就乔装打扮了一番，装扮成他爹的模样，去给李四讲课了，其实孔子讲的是论语，孔子好不容易讲完了，
他说装爹太累了，所以卸下装扮，做回他自己，愉快的玩了一把游戏。
* */
孔子爹 k=new 孔子();
System.out.println(k.age); //60
k.teach(); //讲Java
//向下转型
孔子 kongzi= (孔子) k;
System.out.println(kongzi.age);//30
//调用自己特有的功能
kongzi.playGame();}
}
class 孔子爹{
int age=60;
public void teach(){
System.out.println("讲授Java");}
}
class 孔子 extends 孔子爹{
int age=30;
@Override
public void teach() {
System.out.println("讲论语");}
public void playGame(){
System.out.println("玩游戏");}
}多态的内存图解(理解)多态中的题目分析题(掌握)
A:画图演示: 多态的内存图解五、抽象类的概述及其特点(掌握)
A:抽象类概述
回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。
所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
C:案例演示
抽象类特点抽象类的成员特点(掌握)
A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
抽象类的成员特点
C:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
