序

/*
这周重点内容:ststic关键字;继承(extends);this和super的使用以及区别;final关键字;多态;抽象类的关
键字(abstract);接口(interface,implement);选择排序;形式参数问题以及返回值问题
*/

static关键字

注意事项

/*
1)非静态的方法既可以访问静态变量,也可以访问非静态的变量既可以调用静态方法,也可以调用非静态方法
2)静态的方法:只能访问静态变量,只能调用静态方法
*/
class Demo2{//非静态成员变量public int num = 10 ;//静态变量public static int num2 = 20 ;//定义一个非静态方法public void show(){System.out.println(num);System.out.println(num2);}//非静态方法public void function(){//调用非静态方法show() ;method();}//静态方法public static void method(){//System.out.println(num); //非静态变量System.out.println(num2);//show(); 非静态的方法function2();System.out.println("method demo2...");}//静态方法public static void function2(){System.out.println("function2 demo2...");}
}
//测试类
public class StaticDemo2 {public static void main(String[] args) {//访问Demo2类中的show方法Demo2 d = new Demo2() ;d.show() ;System.out.println("------------------------");d.function();System.out.println("-------------------------");Demo2.method();int result = add(10,20) ;System.out.println(result);}//求两个数据之和public  static int add(int a,int b){return a+ b ;}
}

特点

/*
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();}
}

代码块

分类

/*
局部代码块 :在方法定义中使用 作用:限定局部变量的生命周期
构造代码块:在类的成员位置(类中,方法外),使用{}包裹起来  作用:给类中的一些成员进行数据初始化特点:每次在执行构造方法之前,如果存在构造代码块,先执行构造代码块中的内容!
静态代码块:在类的成员位置,直接使用 static{},特点:随着类的加载而加载,优先于对象存在!作用:也可以通过static代码块,对一些操作(后期IO流创建文件/JDBC(Java链接数据库注册驱动))静态代码块就加载一次!
优先级:静态代码块>    构造代码块  >  构造方法
*/
class Code {//静态代码块static{int x = 1000;System.out.println(x);}//无参构造方法public Code(){System.out.println("code demo...");}//构造代码块{int x = 100 ;System.out.println(x);}{int y  = 200 ;System.out.println(y);}//有参构造方法public Code(String name){System.out.println("code demo"+name);}//静态代码块static{int y = 2000 ;System.out.println(y);}
}
//测试类
public class CodeDemo {public static void main(String[] args) {//定义一个变量// int a = 10 ;//  System.out.println(a);//定义一个局部代码块{int x = 20 ;System.out.println(x); //x的作用域就是在{}内有效}// System.out.println(x);//创建一个Code类对象Code code = new Code() ;System.out.println("-----------");Code code2 = new Code("hello") ;}
}

继承(extends)

概念

/*
将多个类的共性内容抽取到一个独立的类中,然后这多个类和独立的这个类产生一种关系: 继承关系!
*/
class Person{public void eat(){System.out.println("饿了,就需要吃饭...");}public void sleep(){System.out.println("困了,就需要休息...");}
}
//将学生类和工人类:继承自Person
class Student extends  Person{}
class Worker extends  Person{}

好处

/*
1)提高代码的维护性!
2)提高代码的复用性!
3)让类和类之间产生的关系,是"多态的前提条件"
*/

特点

/*
1)类与类之间的关系,继承关系,只支持单继承格式class 子类名 extends 父类名{}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{}
//测试类
public class ExtendsDemo2 {public static void main(String[] args) {//创建子类对象Son son = new Son() ;son.function();son.show();son.method();}
}

注意事项

/*1)子类继承父类:可以继承父类的非私有的成员,私有的成员外界不能访问的,只能在本类中访问但是可以通
过公共方法间接访问!2)构造方法是不能被继承的,但是子类可以间接通过 super关键字访问父类的构造方法(等会讲super)
*/
class Fu{//非私有成员变量public int num = 20 ;private int num2 = 50 ;public void show(){System.out.println(num);System.out.println(num2);System.out.println("-----------------");String str = getStr();System.out.println(str);}//返回String内容private String getStr(){return "hello,extends !" ;}
}
//定义子类
class Zi extends  Fu{//子类自己的方法public void method(){System.out.println("method zi ...");}
}
//测试类
public class ExtendsDemo3 {public static void main(String[] args) {//创建子类对象Zi zi = new Zi() ;System.out.println(zi.num) ;// System.out.println(zi.num2) ; //私有的成员变量System.out.println("----------------------");//访问show方法,show方法公共的,可以被子类继承zi.show() ;zi.method(); //访问自己本类的功能//zi.getStr() ;//父类中私有的成员方法//间接通过公共来调用zi.show() ;}
}

继承关系

/*如果一个A类是B类的一种,或者B类是A类的一种,这个时候就可以使用继承关系继承关系:现实世界事物中本质体现的是一种 "is a"的关系
*/

继承中的方法重写

/*
当前子类继承父类的时候,如果存在方法重写,那么子类重写父类该方法访问权限不能更低!
要么跟父类的方法保持一直,要么带上public(推荐跟父类的方法一直即可!)
*/
class Fu{public void show() {System.out.println("show Fu...");}/*  public void method(){System.out.println("method Fu");}*/void method(){System.out.println("method Fu");}
}
class Zi extends Fu{@Overridepublic  void show() {System.out.println("show Zi..");}/* void method(){System.out.println("method Zi");}*/@Overridepublic void method() {System.out.println("method Zi...");}
}
//测试类
public class OverrideDemo {public static void main(String[] args) {//多态测试Fu fu = new Zi() ;fu.show();}
}

成员变量关系问题

/*
a)子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致,分别访问即可!
b)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致:如何访问呢? (重点)1)首先在子类的局部位置找,是否存在局部变量名称,如果有,就使用2)如果没有,就在子类的成员位置找,是否存在这个变量,如果存在,就使用3)如果在子类的成员位置中没有找到,直接在父类的成员位置中找,如果有,就是使用!4)如果父类的成员位置都没有,就没有这个变量,报错!遵循一个原则:就近原则!
*/
class Fu2{//父类的成员变量int num = 10 ;
}
//子类 Zi2
class Zi2 extends  Fu2{//子类的成员变量//  int num2  = 30 ;// int num = 20 ;//定义一个show方法public void show(){//局部变量//int num = 30 ;System.out.println(num);//   System.out.println(num2);}
}
//测试类
public class ExtendsDemo4 {public static void main(String[] args) {//情况1:子类的成员变量名称和父类的成员变量不一致(简单,分别访问即可)//创建子类对象Zi2 zi2 = new Zi2() ;zi2.show() ;}
}

继承中构造方法的访问

/*
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") ;}
}
/*
2)如果父类中的无参构造方法没有,子类会怎么样?
子类的所有的构造都会报错! (因为子类所有构造方法默认父类的无参构造方法!)
*/
/*
方式1:手动给出父类的无参构造方法(推荐)
方式2:在子类的构造方法中的第一句话:通过super(xxx),间接的访问父类的有参构造方法
方式3:只要子类的所有构造方法中一个能够让父类初始化即可!在子类的有参构造方法中:this():---->访问本类的无参构造方法,然后再子类的无参构造方法中间接访问父类的有参构造方法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("高圆圆") ;}
}

猫狗案例

/*
一般:子类的无参构造:默认访问父类的无参构造方法!子类的有参构造,直接访问父类的有参构造!
*/
//动物类
public class Animal {/***   属性:姓名,年龄,颜色*  *           行为:吃,睡*/private String name ;private int age ;private String color ;//无参构造方法//alt+ins--->Constructor--->Select Nonepublic Animal() {}//有参构造方法//alt+ins--->Constructor--->选中所有字段public Animal(String name, int age, String color) {//"哆唻A梦",1,"蓝白色"this.name = name;this.age = age;this.color = color;}//alt+ins---->Getter and Setter---->选中所有字段public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}//其他行为public void eat(){System.out.println("动物都需要吃饭...");}public void sleep(){System.out.println("动物都需要睡觉...");}
}
//猫继承自动物类
public class Cat extends Animal {public Cat() {//子类无参访问父类的无参构造//super() ;}//子类的有参构造方法访问父类的有参构造方法public Cat(String name, int age, String color) {//Cat c = new Cat("哆唻A梦",1,"蓝白色") ;super(name, age, color);//"哆唻A梦",1,"蓝白色"}//特有功能public void playGame(){System.out.println("猫爱玩毛线...");}
}
//狗类
public class Dog extends Animal {public Dog() {//super() ;}public Dog(String name, int age, String color) {//"小白",5,"白色"super(name, age, color);}//特有功能public void lookDoor(){System.out.println("狗看门..");}
}
public class ExtendsTest {public static void main(String[] args) {//喜欢狗,养一只狗//创建一只狗: 方式1:无参构造方法+setXXX()/getXXX()Dog d = new Dog() ;d.setName("小白");d.setAge(5);d.setColor("白色");System.out.println("狗的姓名是:"+d.getName()+",年龄为:"+d.getAge()+",颜色是:"+d.getColor());d.eat();d.sleep();d.lookDoor();System.out.println("-----------------------------------------");//方式2:有参构造方法+getXXX()Dog d2 = new Dog("小黑",3,"黑色") ;System.out.println("狗的姓名是:"+d2.getName()+",年龄为:"+d2.getAge()+",颜色是:"+d2.getColor());d2.eat();d2.sleep();d2.lookDoor() ;}
}

this 和super的区别

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

final关键字

/*
最终的,无法更改的(状态修饰符)
*/
class Fu{//定义一个show方法public  final void show(){System.out.println("这是一个封绝密文件,任何不得更改!");}
}//定义一个子类
class Zi extends  Fu{//出现了父类一模一样的方法/*public void show(){ //由于现在父类的show加入了final关键字,子类不能重写System.out.println("这是一堆垃圾...");}*/
}
//测试类
public class FinalDemo {public static void main(String[] args) {//创建子类对象Zi zi = new Zi() ;zi.show() ;}
}

特点

/*
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 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修饰基本数据类型和引用类型的区别

/*
final修饰基本数据类型: 基本数据类型的对应的数据值不能在被赋值了,只能赋值一次!
final修饰引用类型:引用数据类型对应的地址值不能被改变
final Student s = new Student() ;//修饰实例变量s,s的堆内存地址值永远是固定值!
s = new Student() ;//重新开辟空间(报错)
*/
class Student{//系统默认无参构造int age = 20 ;
}
public class FinalDemo3 {public static void main(String[] args) {//没有使用final之前int a = 10 ;a = 30 ;a = 100 ;a = 40 ;System.out.println("a:"+a);System.out.println("--------------------------");//final修饰基本类型final int b = 20 ;   //编译时期常量 (jvm不需要加载,检查语法)//b = 50 ;System.out.println("b:"+b);System.out.println("--------------------------");//没有使用final修饰的引用类型Student s = new Student() ;//堆内存中创建了一个空间地址s.age = 40 ;System.out.println(s.age);System.out.println(s);s = new Student() ;System.out.println(s);System.out.println("--------------------------");//final修饰引用数据类型final Student s2 = new Student() ; //运行时期常量(需要jvm加载这个类的),堆内存空间地址值不能被改变!System.out.println(s2);s2.age = 50 ;System.out.println(s2.age);//  s2 = new Student() ; //不能开辟新的堆内存地址,但是里面的成员变量继续更改!}
}

多态

前提条件

/*
1)必须存在继承关系 (extends)
2)必须存在方法重写子类需要覆盖父类的功能
3)必须有父类引用指向子类对象
*/

成员访问特点

/*
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();}
}

多态的好处

/*1)提高代码的复用性:由继承保证)提高了代码的扩展性:由多态保证 (重点)
*/
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("狗侧着睡觉");}
}
//猪类
class Pig extends Animal2{@Overridepublic void eat() {System.out.println("猪吃白菜");}@Overridepublic void sleep() {System.out.println("猪滚着睡觉...");}
}
//定义一个动物类的工具类:AnimalTool
class AnimalTool{//构造方法私有:不让外界newprivate AnimalTool(){}/* public static void createDog(Dog2 d){//如果方法的形式参数是类,----调用该方法传递的实际参数:需要当前类的具体对象d.eat();d.sleep();}//定义创建猫的方法public static void createCat(Cat2 c){c.eat();c.sleep();}*///父类引用可以指向子类对象:形式参数就可以传递Animal2public static void createAnimal(Animal2 a){ //    Animal2 a =  new Dog2();a.eat(); //多态的成员方法访问问题a.sleep();}
}

多态的弊端

/*
能访问子类的特有功能   (Fu f = new Zi())
*/
/*
方案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");}
}

抽象类(abstract)

概念

/*
现实世界事物中,某个事物是比较概括性(人/水果/动物),描述为抽象事物,
只有具体的工人/苹果/猫或者狗,才具备具体的功能;
将某个事物中的一些功能仅仅给出声明即可,没有方法体----->抽象方法---->此时这个类必须为抽象类!
*/

格式

/*
abstract  class 类名{}
权限修饰符(一般情况都是public) abstract 返回值类型  方法名(形式参数列表) ;
*/

特点

/*
1)有抽象方法的类一定是抽象类
2)抽象类中不一定只有抽象方法 ,还可以非抽象方法(有方法体)
3)抽象类不能实例化---->意思:不能创建对象
如何实例化呢:通过具体的子类进行实例化(进行对象的创建), 抽象类多态  Fu fu = new Zi() ;Fu类型 抽象类型
4)抽象类的子类有两种情况:1)目前来说:如果抽象类的子类都是抽象类---毫无意义  因为子类也不能new ,除非再有具体的子类2)抽象类的子类具体类---才能new     :抽象多态的形式  Fu fu = new Zi() ;
*/
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();}
}

抽象类成员特点

/*
成员变量既可以定义变量,也可以常量:被final修饰
成员方法既可以定义为抽象方法,也可以定义为非抽象方法如果定义为抽象方法:关键字abstract(显示给出)
构造方法存在无参构造/有参构造方法---->目的:分层初始化
*/
abstract class Fu{//成员变量public int num = 10 ;//常量public final int num2 = 20 ;public Fu() {System.out.println("Fu...");}//抽象方法public abstract String show() ;  //abstract关键字不能省略//非抽象方法public void method(){System.out.println("method Fu...");}
}
//子类
class Zi extends  Fu{public Zi() {System.out.println("Zi...");}int num = 20 ;@Overridepublic String show() {return "show Zi...";}
}
//测试类
public class AbstractDemo2 {public static void main(String[] args) {//抽象类多态Fu fu = new Zi() ;System.out.println(fu.num);//fu.num2 = 100 ;System.out.println(fu.num2);String zResult = fu.show();System.out.println(zResult);fu.method();}
}

没有抽象方法的抽象类的意义

/*
为了不让它直接实例化!
*/

实例化抽象类

/*
情况1)直接就有具体的子类
情况2)间接的有具体的子类
*/
abstract  class Fu {//定义一个抽象方法abstract  String show() ;// private abstract String method() ;//public static abstract String method() ;//public final abstract String method() ;abstract  String method() ;
}
//具体的子类重写抽象类中的抽象方法
class Zi extends  Fu{@Overridepublic String show() {return "hello,abstract" ;}@OverrideString method() {return "hello,javaEE" ;}
}
//测试类
public class AbstractDemo {public static void main(String[] args) {Fu fu = new Zi() ;String result = fu.show();System.out.println(result);String result2 = fu.method();System.out.println(result2);}
}

abstract和其他关键字

/*
private冲突:私有的方法,只能在本类中访问,加入abstract目的需要被子类重写,需要
调用子类的功能!
static冲突:静态方法随着类的加载而加载,而静态方法---算不上重写,所以它的访问
通过类名.方法名()---->而抽象方法没有方法体
final冲突被final修饰的成员方法是不能被重写的,而加入abstract的方法需要被重写
*/
abstract  class Fu {//定义一个抽象方法abstract  String show() ;// private abstract String method() ;//public static abstract String method() ;//public final abstract String method() ;abstract  String method() ;
}
//具体的子类重写抽象类中的抽象方法
class Zi extends  Fu{@Overridepublic String show() {return "hello,abstract" ;}@OverrideString method() {return "hello,javaEE" ;}
}
//测试类
public class AbstractDemo {public static void main(String[] args) {Fu fu = new Zi() ;String result = fu.show();System.out.println(result);String result2 = fu.method();System.out.println(result2);}
}

接口(interface)

概念

/*
经过培训才能具备的功能------>接口  (比抽象类还抽象)
它的本质就是体现一个现实世界事物所具有的的额外的扩展功能!
*/

格式

/*interface  接口名{}  ------>接口名遵循"标识符规则"---->大驼峰命名法
*/

特点

/*
1)不能实例化(不能创建对象)
2)如何实例化接口实例化: 通过接口的子实现类(一定是具体类)进行实例化----接口多态(使用时最多的!)子实现类和接口的关系: implements 实现关系接口的子实现类如果是抽象类----->肯定要存在抽象类的具体的子类,否则都不能实例化!
*/
interface  Jump{ //跳高接口/* public void jump(){System.out.println("可以跳高了...");}*/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(); //编译看左,运行看右!(接口只能有抽象方法)}
}

成员特点

/*
1)接口中的成员方法:只能是抽象方法,默认的修饰符:public abstract(可以省略不写)
2)接口没有构造方法
3)接口的成员变量只能是常量:存在默认修饰符:public static final (可以省略不写)
*/
interface Inter{//定义一个成员变量public static final int num = 10 ;//public static final int num = 10  ;public static  final  int num2 = 20 ;//public static final int num2 = 20 ;//public Inter(){}void show() ;public abstract  String method();
}
//子实现类
class InterImpl implements  Inter{@Overridepublic void show() {System.out.println("show InterImpl...");}@Overridepublic String method() {return "method InterImpl...";}
}
//测试类
public class InterfaceDemo2 {public static void main(String[] args) {//接口多态Inter inter = new InterImpl() ;// inter.num = 100 ;//改变num的值:改变不了--->存在默认的修饰符 finalSystem.out.println(inter.num);//inter.num2 = 200 ;System.out.println(inter.num2);System.out.println("----------------------");System.out.println(Inter.num);//接口比抽象类还抽象----理解为"更抽象的一个类"----num有static修饰System.out.println(Inter.num2);//static修饰}
}

类与接口

/*
类具体类    class 类名{}抽象类     abstract class 类名{}
接口      inteface 接口名{}类与类之间的关系:    extends 继承关系只支持单继承,不支持多继承,但是可以多层继承类和接口的关系:      implements关系:实现关系一个类继承另一个类的同时,可以实现多个接口,中间逗号给隔开接口与接口之间:            extends:继承关系不仅支持单继承,也可以多继承,中间使用逗号隔开
*/
interface FatherInter{public abstract  void show() ;
}
interface MontherInter{public abstract  void method() ;
}
interface  SonInter extends FatherInter,MontherInter{//可以将两个父接口的功能都继承过来,而且本身接口还可以定义自己的扩展功能public abstract  void function() ;
}
class InterImpl2 implements  SonInter{@Overridepublic void show() {}@Overridepublic void method() {}@Overridepublic void function() {}
}
interface Hunt{//打猎的接口public abstract  void hunt() ;
}
//说英语的接口
interface SpeakEnglish{public abstract  String speak();
}
class GrandFu {public void hello(){System.out.println("我是爷爷");}
}
class Fu extends  GrandFu implements Hunt,SpeakEnglish{public void sayHello(){System.out.println("我是老子...");}@Overridepublic void hunt() {System.out.println("可以打猎了...");}@Overridepublic String speak() {return "可以说英语了...";}
}
/*class Fu2{
}*/
//class Zi extends  Fu,Fu2{}
class Zi extends  Fu{public void show(){System.out.println("我是子类...");}
}
//测试类
public class InterfaceDemo3 {public static void main(String[] args) {Zi zi = new Zi() ; //具体类对象创建zi.show();zi.hello();zi.sayHello();}
}

选择排序

/*使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前放,第一次比较完毕
最小值出现在最小索引处,依次这样比较
比较的次数:数组长度-1次
*/public static void selectSort(int[] arr) {for (int x = 0; x < arr.length-1; x++) {for (int y = x + 1; y < arr.length; y++) {//如果后面的 元素比前面小,互换if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}}}

形式参数问题:引用类型

具体类

/*
调用该方法,实际参数需要传递当前具体类的对象
*/
class Student{public void  study(){System.out.println("学习JavaEE...");}
}
class StudentDemo{public void method(Student s){s.study() ;}
}
//测试类
public class StudentTest {public static void main(String[] args) {//需要访问StudentDemo中的method 方法?//创建StudentDemo类对象StudentDemo sd = new StudentDemo() ;//创建一个具体的学生对象Student student = new Student() ;sd.method(student);System.out.println("-----------------------");//或者匿名对象new StudentDemo().method(new Student());}
}

抽象类

/*
调用该方法实际参数需要传递的抽象类的子类对象 (抽象类多态)
*/
abstract  class Person{//定义一个抽象方法public abstract  void work() ;
}
//PersonDemo类
class PersonDemo{public void show(Person person){    //形式参数是一个抽象类的情况:  Person  p  =   new Programmer();person.work();      //p.work();}
}
//定义Person抽象类的子类
class Programmer extends  Person{@Overridepublic void work() {System.out.println("程序员不断的去学习...");}
}
//测试类
public class PersonTest {public static void main(String[] args) {//需求:要访问PersonDemo类中的show方法?实际参数如何传递?//创建PersonDemo类对象PersonDemo pd = new PersonDemo() ;// Person p = new Person() ; //抽象类不能实例化!   需要借助子类来进行实例化(存在具体的子类)//抽象类多态Person p = new Programmer() ;pd.show(p);System.out.println("-----------------------------");//匿名对象new PersonDemo().show(new Programmer());}
}

接口

/*
调用该方式,实际参数需要传递的是当前接口的子实现类对象(接口多态)
*/
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());}
}

返回值问题:引用类型

具体类

/*
方法返回的就是当前具体类对象!
*/
class Student{public void study(){System.out.println("Good Good Study,Day Day Up!");}
}//StudentDemo类
class StudentDemo {public Student show() { //方法的返回值是引用类型---具体类 :需要返回的当前类的具体对象/*  Student student = new Student() ;//???return student ;*///匿名对象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();}
}

抽象类

/*
需要返回的是抽象类的子类对象
*/
//抽象类
abstract class Person{public  abstract void work() ;
}
//PersonDemo类
class PersonDemo{public Person method(){ //返回值类型是一个引用类型---抽象类的情况,需要返回的是抽象类的子类对象//return ?// Person p = new Person() ;//抽象类不能实例化//抽象类多态// Person p = new Worker() ;//return p ;//一步走//匿名对象return new  Worker() ;}
}
//定义一个子类 继承Person类
class Worker extends  Person{@Overridepublic void work() {System.out.println("工人不断的去工作...");}
}
//测试类
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() ;}
}

接口

/*
需要返回的是该接口的子实现类对象
*/
//定义一个接口
//结婚的接口
interface  Mary{public abstract  void mary() ;
}
//MaryDemo类
class MaryDemo{public Mary function(){//返回值类型是接口类型,//return ?//  Mary mary = new Mary() ; //接口不能实例化//需要提供接口的子实现类对象//接口多态// Mary mary = new You() ;// return mary ;//一步走return new You() ;}
}
//定义一个类
class You implements  Mary{@Overridepublic void mary() {System.out.println("结婚了,很开心...");}
}
//测试类
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();}
}

包(package)

真实含义

/*以后要代码分层...将包进行划分
*/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)功能

权限修饰符

	同一个包下的当前类
private	√
默认修饰符	√
protected	√
public	√

	同一个包下的子类中/无关类中
private
默认修饰符	√
protected	√
public	√

	不同包的子类中
private
默认修饰符
protected	√
public	√

	不同包下的无关类
private
默认修饰符
protected
public	√

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

内部类

内部类和成员内部类

/*
内部类:在一个类中可以定义另一个:在类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();}
}

外部类访问内部类的成员方法

/*
外部类名.内部类名  对象名 =  外部类对象.内部类对象;
*/
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() ;}
}

静态成员内部类

/*如果当前成员内部类是静态的,  里面的方法无论是静态的还是非静态的,都只能访问外部类的静态成员,包括私有!将静态的成员内部类看成是外部类的静态成员访问
直接访问方式外部类名.内部类名 对象名 = 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()静态方法}
}

week_03_常用类以及接口相关推荐

java 接口与包_java常用类包接口
类 String Integer Long File Date Thread (java.lang.Thread Thread类的定义:public class Thread extends Obje ...
Java常用类集接口以及实现方式总结
最近学习map-reduce原理以及map-reduce编程,于是顺带着学习下Java编程,对于Java常用的数据结构和类集,我总结到mind图中,便于理清相互之间的关系 package leiji; ...
【学习笔记】JDBC:java提供的专门操纵数据库的API JDBC驱动程序的类型 JDBC常用的类与接口
JDBC技术 JDBC的全称是Java DataBase Connectivity,是一套面向对象的应用程序接口,指定了统一的访问各种关系型数据库的标准接口,JDBC是一种底层的API,因此访问数据库 ...
SpringMVC常用的视图接口分类及实现类
SpringMVC中常用的视图接口分类及对应的实现类: URL资源视图:InternalResourceView.JstlView 文档视图:AbstractExcelView.AbstractPdf ...
java中常用的包类和接口_java.util包常用的类和接口
标签:ash 可变支持 set 组成 arraylist 层次结构有序结构 1. 常用接口 (1)Collection Collection 层次结构中的根接口 ...
java常用的接口和类的说明,Java程序连接数据库的常用的类和接口介绍
编写访问数据库的Java程序还需要几个重要的类和接口. DriverManager类 DriverManager类处理驱动程序的加载和建立新数据库连接.DriverManager是java.sql包中 ...
Java基础巩固（一）类，接口，枚举，常用API，集合，泛型，正则，数据结构
一.static.final.权限关键字,代码块,接口,枚举 1 关键字 2 代码块 3 接口 4 枚举 idea快捷键 shift + enter 换行 ctrl + Alt + shift + U ...
Java开发常用包、接口和类
一.JDK中常用包 1.java.lang 这个是系统的基础类: 2.java.io 这里面是所有输入输出有关的类,比如文件操作等: 3.java.nio 为了完善 io 包中的功能,提高 io 包中 ...
Java程序员从笨鸟到菜鸟之（五）java开发常用类（包装，数字处理集合等）（下）...
本文来自:曹胜欢博客专栏.转载请注明出处:http://blog.csdn.net/csh624366188 写在前面:由于前天项目老师建设局的项目快到验收阶段,所以,前天晚上通宵,昨天睡了大半天, ...

week_03_常用类以及接口

序

static关键字

注意事项

特点

代码块

分类

继承(extends)

概念

好处

特点

注意事项

继承关系

继承中的方法重写

成员变量关系问题

继承中构造方法的访问

猫狗案例

this 和super的区别

final关键字

特点

final修饰基本数据类型和引用类型的区别

多态

前提条件

成员访问特点

多态的好处

多态的弊端

抽象类(abstract)

概念

格式

特点

抽象类成员特点

没有抽象方法的抽象类的意义

实例化抽象类

abstract和其他关键字

接口(interface)

概念

格式

特点

成员特点

类与接口

选择排序

形式参数问题:引用类型

具体类

抽象类

接口

返回值问题:引用类型

具体类

抽象类

接口

包(package)

真实含义

权限修饰符

内部类

内部类和成员内部类

外部类访问内部类的成员方法

静态成员内部类

week_03_常用类以及接口相关推荐

最新文章

热门文章