第三周 Java语法总结__static关键字__代码块__继承__this和super的区别__重写__final

文章目录

6.static关键字1）静态static关键字的特点:2）关于static关键字的使用注意事项3）什么时候将变量定义为成员变量:7.文档说明书:8.代码块9.继承1）继承的概念2）继承(研究的都是类)的特点3）继承中使用的注意事项4）继承中,每一个成员变量的关系问题10.继承中构造方法的访问11.this和super 的区别12.重写方法重写和方法重载的区别13.final关键字14.多态1.多态的概念2.多态的前提条件3.多态的成员访问特点4.多态的好处5.多态的弊端1）解决方案2）多态的方式:使用向下转型时,可能出现异常6.孔子装爹15.抽象1.抽象类2.抽象类的特点3.abstract和哪些关键字冲突16.接口1.接口2.接口的特点3.接口的子实现类的命名规则4.接口的成员特点5.抽象类和接口之间的区别6.instanceof17.形参问题1.形式参数问题的研究:引用类型2.个方法的返回值是引用类型18.包19.权限修饰符16.内部类1.格式2.外部类访问内部类

6.static关键字

1）静态static关键字的特点:

1)随着类的加载而加载2)优先于对象存在: 它不能this共存 (this:代表当期类对象的地址值引用)对象还没有new的时候,当前被static修饰的成员就已经内存了3)被静态修饰的 可以被多个对象共享:有共享共用的意思举例:饮水机中的水(适合)水杯共享(不适合!)4)被静态修饰的变量,方法----->静态变量或者静态方法我们所说的成员变量和成员方法:都指的是非静态静态的成员的访问方式:类名.变量类名.方法名()

//定义一个类class Demo{//定义一个非静态变量public int num = 100 ;//静态变量public static int num2 = 50 ;//非静态成员方法public void method(){System.out.println("method demo...");}//静态的方法public static void function(){System.out.println("function demo...");}}//测试类public class StaticDemo {public static void main(String[] args){//访问Demo类中num变量Demo d = new Demo() ;System.out.println(d.num);// System.out.println(d.num2); //以后这种方式不要出现//被静态修饰的直接可以通过类名.静态变量名System.out.println(Demo.num2);System.out.println("---------------------------");//访问Demo类中method的方法d.method();// d.function(); //不推荐这样方法:因为function静态Demo.function();}}

2）关于static关键字的使用注意事项

1)非静态的方法既可以访问静态变量,也可以访问非静态的变量既可以调用静态方法,也可以调用非静态方法2)静态的方法:只能访问静态变量,只能调用静态方法简单记:静态只能访问静态

/*** 定义一个Person类*/class Person{String name ;//姓名int age ; //年龄//String country ;//国籍static String country ;//国籍 (类变量:这种变量随着类的加载而加载,优先于对象存在!)//提供无参public Person(){}//提供有参public Person(String name,int age,String country){this.name = name ;this.age = age ;this.country = country ;}public Person(String name,int age){this.name = name ;this.age = age ;}//提供一个show方法显示人的信息public void show(){System.out.println("当前这个人的姓名是:"+name+",年龄是:"+age+",以及国籍是:"+country);}}//测试类public class PersonDemo {public static void main(String[] args){//创建四个人:古代四大美女Person p1 = new Person("西施",25,"中国") ;p1.show();System.out.println("----------------------------");// Person p2 = new Person("貂蝉",26,"中国");Person p2 = new Person("貂蝉",26);p2.show();System.out.println("-----------------------------");// Person p3 = new Person("杨玉环",28,"中国") ;Person p3 = new Person("杨玉环",28) ;p3.show();System.out.println("-----------------------------");// Person p4 = new Person("王昭君",23,"中国") ;Person p4 = new Person("王昭君",23) ;p4.show();//System.out.println(Person.country) ;}}

3）什么时候将变量定义为成员变量:

如果当前这个变量能够描述现实世界事物的属性的时候,这个时候变量就应该定义成员变量,否则局部变量在开发中,尽量采用局部变量:范围小:方法结束,变量从内存消失

7.文档说明书:

针对某个类，加入一些文档注释@author 作者@version 代码版本@since 后面指定JDK版本号以及每一个方法上加入文档注释方法中有参数@param 参数名称 对参数进行解释说明的文字方法中如果有返回值@return 对返回的结果进行解释说明产生文档(document)--html页面打开dos控制台进入指定目录下:javadoc -d 文件夹名称 -author -version java文件(xxx.java --ArrayTool.java)

//这就针对数组操作的工具类/*** 这个类是针对数组操作的工具类,里面提供了数组的遍历,获取数组中的最大值,以及提供冒泡排序,* 以及查询数组中的某个元素的索引值的功能...** @author yang* @version V1.0* */public class ArrayTool {//工具类中一般构造方法私有化的:一般是不让外界直接去new(创建实例)private ArrayTool(){}//printArray是ArrayTool的成员方法//这个类中的所有的成员方法加入static/*** 这个功能是数组的遍历功能,最终遍历的结果形式为[元素1, 元素2, 元素3, ...]* @param arr 它是针对指定的数组进行遍历* */public static void printArray(int[] arr){//ArrayDemo类的成员方法System.out.print("[") ;for (int i = 0; i <arr.length ; i++) {//判断if(i==arr.length-1){System.out.println(arr[i] +"]");}else{System.out.print(arr[i]+", ");}}}/**** 这个功能是针对数组获取最大值* @param arr 在指定的数组中查询* @return 最终返回的就是数组中的最大值*/public static int getMax(int[] arr){//参照物int max = arr[0] ;//遍历其他元素for(int x = 1 ; x < arr.length ; x ++){if(arr[x] > max){max = arr[x] ;}}return max ;}/**** 这个功能是针对数组查询数组中某个元素的索引值* @param arr 在指定的数组中查询* @param key 要查找的指定元素* @return 返回结果就是的索引值,如果找不到,则返回-1*/public static int getIndex(int[] arr,int key){//假设法int index = -1 ;for(int x = 0 ; x < arr.length ; x ++){if(key == arr[x]) {index = x ;break ;}}return index ;}/**** 这个功能是针对数据进行冒泡排序,最终数组是一个有序的* @param arr 针对指定的数组进行排序*/public static void bubbleSort(int[] arr){for(int x = 0 ; x < arr.length-1; x ++){for(int y = 0 ; y < arr.length-1 -x ; y ++){//判断if(arr[y] > arr[y+1]){int temp = arr[y] ;arr[y] = arr[y+1] ;arr[y+1] = temp ;}}}}}

8.代码块

在Java中,使用{}包裹棋起来的内容,成为代码块!分类:局部代码块 :在方法定义中使用 ,作用:限定局部变量的生命周期构造代码块:在类的成员位置(类中,方法外),使用{}包裹起来 作用:给类中的一些成员进行数据初始化特点:每次在执行构造方法之前,如果存在构造代码块,先执行构造代码块中的内容!静态代码块:在类的成员位置,直接使用 static{},特点:随着类的加载而加载,优先于对象存在!作用:也可以通过static代码块,对一些操作(后期IO流创建文件/JDBC(Java链接数据库注册驱动))静态代码块就加载一次!优先级:静态代码块 > 构造代码块 > 构造方法

//看程序写结果/** 考点:* 代码块的优先级* 静态代码块 >构造代码块 > 构造方法** 静态代码块:先执行,而且就执行一次!(因为类就加载一次!)* */class Student{public Student(){System.out.println("Student的无参构造方法");}{System.out.println("Student的构造代码块");}public Student(String name){System.out.println("Student的有参构造方法");}static{System.out.println("Student的静态代码块");}}public class Test {static{System.out.println("高圆圆42了,我很伤心");}public static void main(String[] args) {System.out.println("我是main方法");Student s = new Student() ;Student s2 = new Student("高圆圆") ;}}/*高圆圆42了,我很伤心我是main方法Student的静态代码块Student的构造代码块Student的无参构造方法Student的构造代码块Student的有参构造方法*/

//看程序,写结果class Root {static {System.out.println("Root的静态初始化块"); //1)}{System.out.println("Root的普通初始化块"); //4)}public Root() {System.out.println("Root的无参数的构造器");//5)}}class Mid extends Root {static {System.out.println("Mid的静态初始化块");//2)}{System.out.println("Mid的普通初始化块");//6)}public Mid() {//super();System.out.println("Mid的无参数的构造器");//7)}public Mid(String msg) {//"hello"this(); //访问的是本类的无参构造方法System.out.println("Mid的带参数构造器，其参数值：" + msg);//8)}}class Leaf extends Mid {static {System.out.println("Leaf的静态初始化块");//3)}{System.out.println("Leaf的普通初始化块"); //9)}public Leaf() {super("hello"); //显示访问父类的有参构造方法System.out.println("Leaf的构造器");//10)}}public class LeafTest {public static void main(String[] args) {new Leaf();//匿名对象}}

9.继承

1）继承的概念

将多个类的共性内容抽取到一个独立的类中,然后这多个类和独立的这个类产生一种关系: 继承关系!关键字: extendsclass Fu{}书写格式 :class Zi extends Fu{}继承的好处:1)提高代码的维护性!2)提高代码的复用性!3)类和类之间产生的关系,是多态的前提条件程序开发中:遵循设计原则开闭原则接口分离原则迪米特原则依赖注入原则....这些设计原则都要遵循一个原则 "低(松)耦合,高内聚"(重点)实际开发中:耦合避免不了,但是可以降低(类与类之间的关系越少越好!)内聚:就是解决某件事件的能力!(一个类的能完成的事情,尽量一个类完成,不要产生过多的关系一块完成!)降低耦合性:就可以通过反射(后期:贯穿于整个JavaEE核心技术)来创建某个类的实例!

2）继承(研究的都是类)的特点

1)类与类之间的关系,继承关系,只支持单继承格式class 子类名 extends 父类名{}在有的语言里面,是支持多继承的 (Java中不支持这种写法)class 子类名 extends 父类名1,父类名2,..{}2)虽然不能支持多继承,但是可以支持多层继承!

//多层继承class GrandFather{public void method(){System.out.println("我是爷爷...");}}class Father extends GrandFather{/* public void method(){System.out.println("我是爷爷...");}*/public void show(){System.out.println("shou Father...");}}//单继承class Son extends Father{public void function(){System.out.println("function son...");}}//多继承:类与类之间不支持//class Son extends Father ,Mother{//}

3）继承中使用的注意事项

1)子类继承父类:可以继承父类的非私有的成员,私有的成员外界不能访问的,只能在本类中访问但是可以通过公共方法间接访问!2)构造方法是不能被继承的,但是子类可以间接通过 super关键字访问父类的构造方法

4）继承中,每一个成员变量的关系问题

一个类的组成成员变量构造方法成员方法成员变量a)子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致,分别访问即可!b)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致:如何访问呢? (重点)1)首先在子类的局部位置找,是否存在局部变量名称,如果有,就使用2)如果没有,就在子类的成员位置找,是否存在这个变量,如果存在,就使用3)如果在子类的成员位置中没有找到,直接在父类的成员位置中找,如果有,就是使用!4)如果父类的成员位置都没有,就没有这个变量,报错!遵循一个原则:就近原则!

10.继承中构造方法的访问

1)子类继承父类,子类的所有的构造方法都会默认的访问父类的无参方法子类的所有构造方法的第一句话:默认隐藏了super() ; 因为子类中肯能会使用到父类的数据,所以在继承关系中得先让父类初始化---->构造方法 : 分层初始化!(先父类无参构造方法,在执行子类的构造方法)super:代表的父类对象的空间表示(父类对象的地址值引用!)

//父类class Fu{// private String name ;// private int age ;//父类的无参构造方法public Fu(){System.out.println("Fu的无参构造方法...");}public Fu(String name){System.out.println("Fu的有参构造方法...");}}//子类class Zi extends Fu{public Zi(){// super() ;//隐藏一个关键字super() ; 访问父类的无参构造方法System.out.println("Zi的无参构造方法");}public Zi(String name){// super() ;System.out.println("Zi的有参构造方法");}}//测试类public class ExtendsDemo {public static void main(String[] args) {//创建子类对象Zi zi = new Zi() ;System.out.println("------------------------");//有参构造创建对象Zi zi2 = new Zi("hello") ;}}/*Fu的无参构造方法...Zi的无参构造方法------------------------Fu的无参构造方法...Zi的有参构造方法*/

2)如果父类中的无参构造方法没有,子类会怎么样?子类的所有的构造都会报错! (因为子类所有构造方法默认父类的无参构造方法!)

如何解决呢?方式1:手动给出父类的无参构造方法(推荐)方式2:在子类的构造方法中的第一句话:通过super(xxx),间接的访问父类的有参构造方法方式3:只要子类的所有构造方法中一个能够让父类初始化即可!在子类的构造方法中:this(xxx):---->访问本类的构造方法,然后再子类的构造方法中间接访问父类的有参构造方法super(xxx) ;

//父类class Father{//父类的无参构造方法/* public Father(){System.out.println("Fu的无参构造方法...");}*/public Father(String name){System.out.println("Fu的有参构造方法...");}}//子类class Son extends Father{public Son(){super("随便给") ;System.out.println("Zi的无参构造方法");}public Son(String name){// super("随便给") ;this() ;//访问本类的无参构造方法System.out.println("Zi的有参构造方法");}}//测试类public class ExtendsDemo2 {public static void main(String[] args) {Son s = new Son() ;Son s2 = new Son("高圆圆") ;}}/*Fu的有参构造方法...Zi的无参构造方法Fu的有参构造方法...Zi的无参构造方法Zi的有参构造方法*/

11.this和super 的区别

总结:this和super 的区别this:代表的当前类对象的地址值引用super:代表的父类对象的地址值引用(代表父类的空间标识)访问成员变量this.变量名; 访问的本类中的成员变量super.变量名; 访问的是父类的成员变量访问构造方法:this() ; 访问本类的无参构造方法super() ;访问的父类的无参构造方法this(xxx);访问的本类的有参构造方法super(xxx);访问的父类的有参构造方法成员方法:this.方法名();访问的是本类的成员方法super.方法名() ;访问的是父类的成员方法

12.重写

重写：如果子类出现了和父类一模一样的方法声明,叫做方法重写!(Override) ---方法复写(覆盖)重写的目的:子类有自己的功能,需要将父类的该功能覆盖掉!

重写权限

当前子类继承父类的时候,如果存在方法重写,那么子类重写父类该方法访问权限不能更低!要么跟父类的方法保持一直,要么带上public(推荐跟父类的方法一直即可!)

//定义一个手机类 :Phoneclass Phone{//打电话public void call(){System.out.println("手机可以打电话...");}}//新的手机类class NewPhone extends Phone{//子类出现了和父类一模一样的方法声明:沿用打电话的功能,并且还需要提供新的功能//@Override :标记当前这个方法是重写父类的方法 (JDK提供的内置注解)public void call(){System.out.println("可以看天气预报了...") ;//沿用父类的功能super.call();System.out.println("还可以听音乐...") ;}}//测试类public class ExtendsDemo2 {public static void main(String[] args) {//创建子类对象NewPhone np = new NewPhone() ;np.call();}}

方法重写和方法重载的区别

面试题:方法重写和方法重载的区别?方法重载: 在一个类中,提供n多个功能,这些功能,方法名相同,参数列表不同,与返回值无关(目的:提高某个功能的扩展性)参数列表不同:1)类型不同2)个数不同3)考虑参数类型的顺序public static void open(int a,double d){}public static void open(double a,int b){}构造方法也可以重载!方法重写:在继承关系中,子类出现了父类一模一样的方法声明,重写的目的:子类有自己的功能,需要将父类的该功能覆盖掉!举例:动物:都具备吃和睡的功能猫和狗都继承自动物类,他们吃的不一样的猫和狗就需要讲吃和睡的功能覆盖掉...猫具体吃鱼狗具体吃肉

13.final关键字

final(状态修饰符):最终的,无法更改的关于final关键字的特点:1)可以修饰类,该类不能被继承!2)可以修饰符成员方法,成员方法不能重写! (根据具体的题意要求!)3)可以修饰的变量,这个变量此时是一个常量! (自定义常量)

class Fu2{public int num = 20 ;public final int num2 = 30; //就是 不能更改的变量: 值永远是30 (自定义常量)public final void method(){System.out.println("method Fu2...");}}//定义一个子类class Zi2 extends Fu2{/*public void method(){System.out.println("method Zi2...");}*///子类自己的功能public void show(){final int num3 ; //被final修饰的局部变量:可以先定义,但是必须在使用前初始化,只能赋值一次num3 = 40 ;System.out.println(num3);// num3 = 50 ;}}//测试类public class FinalDemo2 {public static void main(String[] args) {//创建子类对象Zi2 zi2 = new Zi2() ;zi2.method();System.out.println("--------------------");zi2.num = 100 ;System.out.println(zi2.num);//zi2.num2 = 50 ; //被final修饰的变量,只能赋值一次,不能再次赋值!System.out.println(zi2.num2);zi2.show();}

面试题:final ,finally,finalize()的区别?final的关键字描述以及的三个特点finally:处理异常用到 try...catch...finally(后面讲)finalize():跟垃圾回收器有关系:回收内存中没有更多引用的对象(后面在讲常用类使用以下)

final修饰变量,此时变量是一个常量变量:普通变量final int a = 10 ;实例变量final Student s = new Student() ;

final修饰基本数据类型和引用类型的区别?final修饰基本数据类型: 基本数据类型的对应的数据值不能在被赋值了,只能赋值一次!final修饰引用类型:引用数据类型对应的地址值不能被改变final Student s = new Student() ;//修饰实例变量s,s的堆内存地址值永远是固定值!s = new Student() ;//重新开辟空间(报错)开发中书写常量:都使用public static final int a = 100 ;public:访问权限足够大static:可以被类名直接访问final:这个变量是一个常量class Constant{public static final int a = 100 ; //自定义常量public static final Student s = new Student() ;//成员位置定义的:静态实例变量}Constant.a:类名.变量名;

14.多态

1.多态的概念

多态：一个事物在不同时刻不同形态举例:现实世界事物 :水气态,固态,液态程序世界:在内存中的变化猫是动物 Animal a = new Cat() ;猫是猫: Cat c = new Cat() ;

2.多态的前提条件

1)必须存在继承关系 (extends)2)必须存在方法重写子类需要覆盖父类的功能Animaleat():"动物都需要吃饭..."Cateat() "猫吃鱼"Dogeat() "狗吃骨头"3)必须有父类引用指向子类对象class Fu{}class Zi extends Fu{//存在重写}格式: Fu fu = new Zi() ;

3.多态的成员访问特点

Fu fu = new Zi() ;1)针对成员变量的访问问题:编译看左,运行看左!(使用父亲的东西)2)针对多态中的成员方法的访问问题: 我们所说的成员变量/成员方法----非static编译看左,运行看右(因为子类重写了父类的东西)3)如果成员方法是静态方法:(静态成员方法 算不上方法重写,直接可以类名来访问,跟类相关的方法)编译看左,运行看左4)构造方法:存在继承关系: 还需要让父类先构造初始化,然后再子类进行构造初始化!(分层初始化!)

//动物类class Animal{int age = 10 ;public void eat(){System.out.println("动物饿了就需要吃饭...");}public Animal(){System.out.println("Animal的无参构造方法");}//父类的静态showpublic static void show(){System.out.println("show animal...");}}//猫类class Cat extends Animal{int age = 3 ;public Cat(){System.out.println("Cat无参构造方法");}public void eat() {//猫吃鱼System.out.println("猫吃鱼");}//子类的静态showpublic static void show(){System.out.println("show Cat...");}}//测试类public class DuoTaiDemo {public static void main(String[] args) {//使用多态来进行测试//父类引用指向子类对象// 格式: Fu fu = new Zi() ;Animal a = new Cat() ;System.out.println(a.age);a.eat();// a.show() ;//静态方法当然推荐这种访问// Animal.show();//Cat.show();}}

4.多态的好处

1)提高代码的复用性:由继承保证2)提高了代码的扩展性:由多态保证 (重点)Fu fu = new Zi() ; 父类引用可以指向子类对象

//有一个动物类class Animal2{//吃和睡public void eat(){System.out.println("动物饿了,都需要吃饭...");}public void sleep(){System.out.println("动物困了,都需要休息...");}}//两个子类class Cat2 extends Animal2{@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void sleep() {System.out.println("猫趴着睡觉");}}class Dog2 extends Animal2{@Overridepublic void eat() {System.out.println("狗吃骨头");}@Overridepublic void sleep() {System.out.println("狗侧着睡觉");}}//定义一个动物类的工具类:AnimalToolclass AnimalTool{//构造方法私有:不让外界newprivate AnimalTool(){}//父类引用可以指向子类对象:形式参数就可以传递Animal2public static void createAnimal(Animal2 a){// Animal2 a = new Dog2();a.eat(); //多态的成员方法访问问题a.sleep();}}//测试类public class DuoTaiDemo2 {public static void main(String[] args) {//具体的动物类创建对象//喜欢狗--创建一只狗Dog2 d = new Dog2() ;d.eat();d.sleep();//创建第二只Dog2 dd = new Dog2();dd.eat();dd.sleep();System.out.println("----------------------");//创建猫Cat2 c = new Cat2() ;c.eat();c.sleep();//第二只猫Cat2 cc = new Cat2() ;cc.eat();cc.sleep();System.out.println("=============================================");//上面的问题:随着类型的增加(猴子,猪,大象...),不但提供的对应类型还需要通过createXXX(XXX 类型)//继续优化:单独定义一个动物类的工具类AnimalTool(构造方法私有化,提供对外的静态功能)// AnimalTool.createDog(new Dog2());//AnimalTool.createCat(new Cat2());//代码:只是将两个功能封装到一个工具类AnimalTool中,随着动物类型不断增加,createXXX()不断增加//形式参数传递的是一个父类,父类引用指向子类对象AnimalTool.createAnimal(new Dog2()); //Animal2 a = new Dog2() ;AnimalTool.createAnimal(new Cat2()); //Animal2 a = new Cat2() ;}}

5.多态的弊端

不能访问子类的特有功能 (Fu f = new Zi())f.方法名() ;报错了. 父类中没有子类特有功能!

class Father{public void show(){System.out.println("show father...");}}//子类class Son extends Father{public void show(){System.out.println("show son...");}//特有功能:public void playGame(String gameName){System.out.println("会玩"+gameName+"游戏");}}//测试类public class DuoTaiDemo3 {public static void main(String[] args) {//父类引用指向子类对象:向上转型Father father = new Son() ;father.show();//father.playGame() ; //编译都报错了: 父类中没有玩游戏的功能 ,玩游戏属于Son类的特有功能System.out.println("-------------------------");}}

1）解决方案

方案1: (不推荐)具体的子类创建具体的子类对象 Zi z = new Zi() ;z.成员方法名() ;本身Fu f = new Zi() ;已经在堆内存中开辟空间了Zi z = new Zi() ;在堆内存中又开辟空间,从内存角度考虑,这种比较消耗内存空间,不太好!方案2:(推荐使用:"向下转型")多态的第三个前提条件:父类 引用指向子类对象:"向上转型 "Fu f = new Zi() ;能不能将父类的引用转换成子类的引用? 好处:不需要在堆内存开辟空间可以------>"向下转型"Zi z = (Zi)f ; 还原成子类型强转类型转换: 目标类型 变量名 =(目标类型)初始化值;

//父类class Father2{public void show(){System.out.println("show father...");}}//子类class Son2 extends Father2{public void show(){System.out.println("show son...");}//特有功能:public void playGame(String gameName){System.out.println("会玩"+gameName+"游戏");}}//测试类public class DuoTaiDemo4 {public static void main(String[] args) {//父类指向子类对象Father2 father2 = new Son2() ;father2.show(); //编译看左,运行看右,存在重写//father2.playGame( "lol");//父类没有方法System.out.println("------------------------------");//方案1:创建具体的子类对象Son2 son2 = new Son2() ;son2.playGame("lol");System.out.println("------------------------------");/*** "向下转型"* Zi z = (Zi)f ; 还原成子类型*/Son2 s = (Son2) father2;s.playGame("csgo");}

2）多态的方式:使用向下转型时,可能出现异常

要使用向下转型,前提必须有父类引用指向子类对象 Fu f = new Zi() ;遵循向下转型的格式:Zi z = (Zi)f;必须心里清楚堆内存存储的类型....向下转型使用不当,就出现java.lang.ClassCastException:类转换异常: (属于运行时期异常)当前堆内存中的实例不是该类型时,就会出现问题!

//定义一个动物类class Animal{public void eat(){System.out.println("动物都需要吃饭");}}//狗类class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}}//猫类class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}}//测试类public class DuoTaiDemo {public static void main(String[] args) {//多态版测试猫Animal a = new Cat() ;//此时 堆内存是猫 (猫是动物)Cat c = (Cat) a ; //还原成猫类型 :猫是猫a = new Dog() ; //此时:堆内存是狗 (狗是动物)Dog d = (Dog)a; //还原成狗的类型: 狗是狗Cat cc = (Cat)a ;//现在没有报错:语法正确的:符合强转类型语法格式，运行出错java.lang.ClassCastException:类转换异常}}

6.孔子装爹

15.抽象

1.抽象类

什么是抽象类----->现实世界事物中,某个事物是比较概括性(人/水果/动物),描述为抽象事物将一些公共性内容抽取到独立的类中，并且有些功能仅仅给出声明，不具体实现，具体实现通过子类进行，只有具体的工人/苹果/猫或者狗,才具备具体的功能;将某个事物中的一些功能仅仅给出声明即可,没有方法体----->抽象方法---->此时这个类必须为抽象类!举例:动物都需要吃和睡只要看到具体的动物类:猫类/狗类,才具备吃和睡的功能将动物类中的吃和睡给出一个声明:加入一个关键字 abstract:抽象方法动物类----->抽象类* 抽象的关键字:Java语言 :abstract关键字 (抽象的含义)抽象方法的格式;权限修饰符(一般情况都是public) abstract 返回值类型 方法名(形式参数列表) ;抽象类的格式:abstract class 类名{}

2.抽象类的特点

1)有抽象方法的类一定是抽象类2)抽象类中不一定只有抽象方法 ,还可以非抽象方法(有方法体)3)抽象类不能实例化---->意思:不能创建对象如何实例化呢:通过具体的子类进行实例化(进行对象的创建), 抽象类多态 Fu fu = new Zi() ;Fu类型 抽象类型4)抽象类的子类有两种情况:1)目前来说:如果抽象类的子类都是抽象类---毫无意义 因为子类也不能new ,除非再有具体的子类2)抽象类的子类具体类---才能new:抽象多态的形式 Fu fu = new Zi() ;抽象类的核心宗旨:就是强制子类必须完成的事情(要将父类中的所有的抽象方法必须重写,否则报错!)

抽象类成员特点:成员变量既可以定义变量,也可以常量:被final修饰成员方法既可以定义为抽象方法,也可以定义为非抽象方法如果定义为抽象方法:关键字abstract(显示给出)构造方法存在无参构造/有参构造方法---->目的:分层初始化

//定义一个动物类abstract class Animal{/*public void eat(){System.out.println("动物都需要吃饭");}*/public abstract void eat(); //加入关键字abstractpublic void show(){//具体方法System.out.println("show animal...");}public abstract void slepp() ;//睡public Animal(){//Animal抽象类=---- 不能new Animal()System.out.println("Animal的无参构造方法");}}//子类//目前来说:如果抽象类的子类都是抽象类---毫无意义 因为子类也不能new ,除非再有具体的子类//abstract class Cat extends Animal{//具体类class Cat extends Animal{public Cat(){System.out.println("Cat的无参构造方法");}@Overridepublic void eat() {System.out.println("猫吃鱼...");}@Overridepublic void slepp() {System.out.println("猫趴着睡觉...");}//特有功能public void playGame(){System.out.println("猫玩毛线");}}class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}@Overridepublic void slepp() {System.out.println("狗侧着睡觉...");}//特有功能public void catchRabit(){System.out.println("狗可以抓兔子");}}//测试类public class AbstractDemo {public static void main(String[] args) {//创建动物类对象//类名 对象名 = new 类名() ;// Animal a = new Animal() ;//不能创建对象,如何实例化呢?//使用多态的形式: 当前的Animal类的子类一定是具体类Animal a = new Cat() ;//父类引用指向子类对象(父类---抽象类) : 抽象类多态a.eat();a.slepp();// a.playGame() ; 父类没有这个功能//向下转型Cat c = (Cat)a ;c.playGame();System.out.println("-------------------------");a = new Dog() ;a.eat();a.slepp();Dog d = (Dog) a;d.catchRabit();}}

面试题:一个类中没有抽象方法,那么将这个类定义为抽象类的意义何在?意义:为了不让它直接实例化!如何实例化:情况1)直接就有具体的子类情况2)间接的有具体的子类可能:某个功能的返回值是它本身----->功能里面的逻辑可能就是在new 最具体的子类!

3.abstract和哪些关键字冲突

1）private冲突:私有的方法,只能在本类中访问,加入abstract目的需要被子类重写,需要调用子类的功能!2）static冲突:静态方法随着类的加载而加载,而静态方法---算不上重写,所以它的访问通过类名.方法名()---->而抽象方法没有方法体3）final冲突被final修饰的成员方法是不能被重写的,而加入abstract的方法需要被重写的!abstract能够跟的关键字public默认修饰符protected:受保护的 (范围:同一个包下的当前类或者子类中或者不包下的子类)abstract一般在类上使用---->抽象类在方法上使用---->抽象方法可以在接口中使用

16.接口

1.接口

接口---->它的本质就是体现一个现实世界事物所具有的的额外的扩展功能!定义格式: interface 接口名{} ------>接口名遵循"标识符规则"---->大驼峰命名法接口中的方法:不能有方法体,隐藏public abstract关键字,只能是抽象方法,不能有方法体

2.接口的特点

1)不能实例化(不能创建对象)2)如何实例化接口实例化: 通过接口的子实现类(一定是具体类)进行实例化----接口多态(使用时最多的!)子实现类和接口的关系: implements 实现关系接口的子实现类如果是抽象类----->肯定要存在抽象类的具体的子类,否则都不能实例化!

3.接口的子实现类的命名规则

开发中--->在接口名的后面+Impl:子实现类interface Inter{}class InterImpl implements Inter{}

//定义一个接口:interface Jump{//跳高接口public abstract void jump() ;}//定义一个跳高猫类class JumpCat implements Jump{//实现关系--->关键字:implements@Overridepublic void jump() {System.out.println("猫可以跳高了...");}}//测试类public class InterfaceDemo {public static void main(String[] args) {//创建接口对象//Jump jump = new Jump() ;//不能实例化//接口多态:----- 之前抽象类多态:Fu fu = new Zi() ; Fu类抽象类//接口--->指向子类实现类对象Jump jump = new JumpCat() ;jump.jump(); //编译看左,运行看右!(接口只能有抽象方法)}}

4.接口的成员特点

1)接口中的成员方法: 只能是抽象方法,默认的修饰符:public abstract(可以省略不写)2)接口没有构造方法3)接口的成员变量只能是常量: 存在默认修饰符:public static final (可以省略不写)

5.抽象类和接口之间的区别

1)成员的区别:抽象类中成员变量:既可以是常量,也可以是变量成员方法:既可以是抽象方法(abstract不能省略),也可以是非抽象方法构造方法:既存在无参构造方法,也可以存在有参构造方法(目的:为了给当前类进行数据初始化)abstract class Animal{private String name ;private int age ;private String color ;public Animal(){}pbblic Animal(String name,int age,String color){this.name = name ;this.age = age ;this.color = color ;}public abstract void eat() ;}class Cat extends Animal{public Cat(){}public Cat(String name,int age,String color){super(name,age,color) ;}public void eat(){//...}}Animal a = new Cat() ; //抽象类多态接口中成员变量:只能是常量,存在默认的 修饰符 public static final (可以省略不写)成员方法:只能是抽象方法:存在默认修饰符 public abstract(省略不写)构造方法:没有构造方法,接口中所有的方法---都认为是没有方法体2)关系的区别三点类与类之间的关系: extends 继承关系只支持单继承,不支持多继承,但是可以多层继承类和接口的关系: implements关系:实现关系个类继承另一个类的同时,可以实现多个接口,中间逗号给隔开接口与接口之间: extends:继承关系不仅支持单继承,也可以多继承,中间使用逗号隔开3)设计理念的区别抽象类--->不能实例化---通过具体的子类实例化---->存在继承关系,体现的是一种 "is a"的关系接口---->不能实例化--->通过具体的子实现类实例化---->谁如果实现了接口,就具备额外的功能,体现的是一种"like a"的关系

6.instanceof

instanceof:提供操作符号(二元(二目)操作符号:) 最终true/false==>=<=><对象 instanceof 引用类型描述左边的对象是否是当前右边的类型的实例 (实例---->对象)

abstract class Animal{public Animal() {}public abstract void eat() ;}class Dog extends Animal{public Dog() {}@Overridepublic void eat() {System.out.println("狗吃骨头");}}class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}}class Pig extends Animal{@Overridepublic void eat() {System.out.println("猪吃白菜...");}}//测试类public class Test3 {public static void main(String[] args) {Animal a = new Dog() ;a = new Pig() ;//if语句if(a instanceof Dog){System.out.println("是狗类型的实例");}else if(a instanceof Cat){System.out.println("是猫类型的实例");}else if(a instanceof Pig){System.out.println("是猪类型的实例");}else{System.out.println("对不起,没有当前实例...");}}}

17.形参问题

1.形式参数问题的研究:引用类型

形式参数问题的研究:引用类型如果方法的形式参数是类 调用方法的时候,如何传递实际参数?具体类 ：调用该方法,实际参数需要传递当前具体类的对象抽象类 ：调用该方法实际参数需要传递的抽象类的子类对象 (抽象类多态)接口 ： 调用该方式,实际参数需要传递的是当前接口的子实现类对象(接口多态)

//定义一个接口interface Love{void love() ;}//LoveDemo类class LoveDemo {//Love love = new LovePerson() ppublic void function(Love l){//方法的形式参数是接口类型,必须传递接口的子实现类对象l.love();//love.love() ;}}//定义一个接口的子实现类class LovePerson implements Love{@Overridepublic void love() {System.out.println("爱生活,爱Java,爱高圆圆...");}}//测试类public class LoveTest {public static void main(String[] args) {//需要访问LoveDemo类中的function方法//创建LoveDemo类对象LoveDemo ld = new LoveDemo() ;//Love love = new Love() ; //接口不能实例化//接口多态Love love = new LovePerson() ;ld.function(love) ;System.out.println("------------------------");//匿名对象new LoveDemo().function(new LovePerson());}}

2.个方法的返回值是引用类型

如果一个方法的返回值是引用类型,最终方法结束,如何返回?具体类 :方法返回的就是当前具体类对象!抽象类 :需要返回的是抽象类的子类对象接口:需要返回的是该接口的子实现类对象

1）具体类

class Student{public void study(){System.out.println("Good Good Study,Day Day Up!");}}//StudentDemo类class StudentDemo {public Student show() {//方法的返回值是引用类型---具体类 :需要返回的当前类的具体对象return new Student();}}//测试类public class StudentTest {public static void main(String[] args) {//调用StudentDemo类中的show方法?//创建StudentDemo类对象StudentDemo sd = new StudentDemo() ;Student s = sd.show(); //Student s = new Student(); sd.show()---->返回的具体的学生对象s.study();System.out.println("-----------------------");//匿名对象Student student = new StudentDemo().show();student.study();}}

2）抽象方法

abstract class Person{public abstract void work() ;}//定义一个子类 继承Person类class Worker extends Person{@Overridepublic void work() {System.out.println("工人不断的去工作...");}}//PersonDemo类class PersonDemo{public Person method(){//返回值类型是一个引用类型---抽象类的情况,需要返回的是抽象类的子类对象// Person p = new Worker() ;//return p ;//一步走//匿名对象return new Worker() ;}}//测试类public class PersonTest {public static void main(String[] args) {//需要调用PersonDemo类中的method 方法?PersonDemo pd = new PersonDemo() ;Person person = pd.method(); // method方法其完成了一件事件: Person person = new Worker() ;person.work() ;System.out.println("---------------------------------");//匿名对象Person p = new PersonDemo().method();p.work() ;}}

3）接口

//定义一个接口//结婚的接口interface Mary{public abstract void mary() ;}//定义一个类class You implements Mary{@Overridepublic void mary() {System.out.println("结婚了,很开心...");}}//MaryDemo类class MaryDemo{public Mary function(){//返回值类型是接口类型,//需要提供接口的子实现类对象//接口多态// Mary mary = new You() ;// return mary ;//一步走return new You() ;}}//测试类public class LoveTest {public static void main(String[] args) {//调用MaryDemo类中的function方法?MaryDemo maryDemo = new MaryDemo() ;Mary mary = maryDemo.function();mary.mary();System.out.println("----------------------");//匿名对象Mary m = new MaryDemo().function();m.mary();}}

18.包

包:关键字 package包的真实含义:以后要代码分层...将包进行划分开发中,写包名的时候(字母都是小写,多级包) :公司域名反写开发中:先按照模块划分,在按照功能划分用户模块注册功能登录功能用户激活功能(使用邮件激活技术,手机短信验证,微信二维码)用户退出商品模块订单模块购物车模块支付模块举例:com.qf.pojo/entity/domain : 存储实体类comqfpojo存储实体类----能够描述现实世界事物User类 用户name,password,birthday,sex,email属性:姓名,密码,出生日期,性别,邮箱商品实体商品Product属性:商品名称,商城价格,市场价格上架日期,pname,shop_price,market_price,pdesc,pdate,....开发中:com.qf.dao : 数据库访问层comqfdaoUserDao: 用户数据库持久层 (针对用户数据库访问接口层---->JDBC(Java连接数据库))两个功能:注册/登录功能public abstract boolean isLogin(User user) ;public abstract boolean register(User user) ;com.qf.dao.impl(针对用户数据库访问接口实现层)UserDaoImpl implements UserDao重写isLogin(User user)和register(User user)功能业务层代码:com.qf.service :UserService:针对用户的业务接口层登录/注册的业务com.qf.service.impl:针对用户的业务接口实现层UserServiceImpl implements UserService注册:判断用户名和密码在数据库中是存在,如果存在,就不能在注册了;如果不存在,可以进行注册登录:首先通过用户名先找到用户User----如果找到User继续判断 User里面的密码是否和前台输入的密码是否一致,如果一致,登录成功,否则,错误信息提示....控制层: 控制业务层数据--->进行页面的渲染(视图):jsp,freemarker:网页静态化.... (模板引擎)com.qf.controller:UserController :调用UserService层:获取业务层数据通过后期:请求转发/重定向技术---进行页面跳转 (后期:开源框架:springmvc:视图解析器)

19.权限修饰符

修饰的权限从小到:private,默认,protected,public

16.内部类

1.格式

内部类:在一个类中可以定义另一个:在类A 中定义了类B,将类B就称为类A的内部类,类A就是外部类!成员内部类:在一个类的成员位置中定义了另一个类内部类可以访问外部类的成员,包括私有!

//外部类class Outer{//成员变量public int num = 100 ;private int num2 = 200 ;class Inner{//成员内部类//成员内部类的一个成员方法public void method(){System.out.println("method Inner");System.out.println();System.out.println(num2);}}//外部类的成员方法public void show(){//访问的成员内部类的method--->通过创建内部类对象来访问//method() ;错误的----访问的本类的method方法Inner inner = new Inner() ;inner.method();}}//测试public class InnerClassDemo {public static void main(String[] args) {//创建外部类对象Outer outer = new Outer() ;outer.show();}}

2.外部类访问内部类

1）外部类如何直接访问内部类的成员方法?格式:外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象() ;

class Outer2{private int num = 20 ;//成员内部类class Inner2{public void show(){System.out.println(num);}}//外部类的成员方法public void method(){// 创建内部类对象访问内部类的成员方法}}//测试类public class InnerClassDemo2 {public static void main(String[] args) {//外部类名.内部类名 对象名 = 外部类对象.内部类对象;//适用于:通过外部类直接访问成员内部类的成员(前提条件:当前成员内部类是一个非静态类)Outer2.Inner2 oi = new Outer2().new Inner2() ;oi.show() ;}}

2）关于我们成员内部类的修饰符:在成员内部类上面---加入private修饰:为了数据的安全性,它的访问---就要外部类的公共访问间接访问...

伪代码举例:人首先身体---身体内有心脏class Body{//内部类:心脏private class Heart{//加入private:保证数据的安全性//手术public void operator(){System.out.println("心脏搭桥手术....") ;}}//外部类提供一些公共访问public void method(){if("如果你是外科医生"){Heart heart = new Heart() ;heart.operator() ;}}}//外部类直接访问成员内部类的成员

3）如果当前成员内部类是静态的, 里面的方法无论是静态的还是非静态的,都只能访问外部类的静态成员,包括私有!如何直接访问静态成员内部类的成员呢?将静态的成员内部类看成是外部类的静态成员访问直接访问方式外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

class Outer3{//定义非静态的成员变量public int num = 50 ;private static int num2 = 20 ;//定义成员内部类:静态的 ---->静态的成员内部类可以看成是外部类的静态成员static class Inner3{//此时类都是静态public void show(){// System.out.println(num);System.out.println(num2);}public static void show2(){// System.out.println(num);System.out.println(num2);}}}//测试类public class InnerClassDemo3 {public static void main(String[] args) {// 外部类名.内部类名 对象名 = 外部类对象.内部类对象;//Outer3.Inner3 oi = new Outer3().new Inner3() ; 适用不了了// 外部类名.内部类名 对象名 = new 外部类名.内部类名() ;Outer3.Inner3 oi = new Outer3.Inner3() ;oi.show();oi.show2() ; //静态---不推荐对象名访问System.out.println("------------------------------");//show2()的另一种方式Outer3.Inner3.show2(); //show2()静态方法}}

第三周 Java语法总结__static关键字__代码块__继承__this和super的区别__重写__final关键字__多态__抽象__接口__形参问题__包__权限修饰符__内部类