day10
1.代码块
在Java中使用{}包裹起来的内容，将这个{}称为代码块！
分类:1)局部代码块： 在方法定义中定义的{}
作用：限定局部变量的生命周期
2)构造代码块:在类中的成员位置中定义的{}
作用:在执行构造方法之前先执行构造代码块,然后对当前数据(类中的成员变量)进行初始化
将构造方法中共性内容存储到构造代码块中 (一般情况都是通过构造方法初始化)
3)静态代码块:在类中的成员位置定义的 static{}
作用:随着类的加载加载,在{}里面给数据进行初始化 整个{}优先于对象存在
而且静态代码块执行只执行一次!(因为类就加载一次!)
结论: 优先级: 静态代码块 > 构造代码块 > 构造方法
静态代码块的特点:随着了类的加载而加载,因为类的加载一次,静态代码块只执行一次
局部变量不用加权限修饰符的,因为局部变量本身就是一个访问限定!因为跟方法有关系.
static不能修饰局部变量,局部变量随着方法调用而存在,随着方法调用结束而消失(释放掉),而被static修饰的变量有一个特点:可以被共用, 方法调用完毕需要释放掉局部变量,这种情况产生冲突.
但是可以使用final修饰符(状态修饰符),它修饰符的变量在内存中是一个固定的常量(永驻内存的)
2.继承
继承: 需要定义独立的类,将其他类的共性内容抽取到该独立的类中,让其他类和这个独立类的产生一种关系: "继承"关系
继承的好处:
1)提供了代码的复用性 (代码结构清晰)
2)提供了了代码的维护性
3)类和类产生的这种"继承关系",是多态的前提条件
继承的关系也是一种弊端,类和类产生,耦合性就增强了
开发的原则:Java很多的开发原则都要遵循下面这个:低耦合,高内聚
耦合:尽量的一个类能完成的事情一个类去完成,不要产生过多的关系. (spring框架的IOC:控制反转)
内聚:执行某件事情的能力!
继承的特点:
1)在Java语言中,类和类之间只支持单继承,不支持多继承
在其他语言中,是支持多继承的,语法格式:子类名 extends 父类名1,父类名2{}
2)虽然不支持多继承,但是类与类之间是可以多层继承的!
继承中的注意事项:
1)子类继承父类,可以继承父类中所有的非私有的成员!
本身私有的成员变量/成员方法只能在本类中访问,外界不能访问的!,但是间接通过公共的访问方法来访问
2)子类继承父类,不继承父类构造方法,但是可以通过一个关键字来访问父类的构造方法(super)
3)不要为了使用部分功能而去使用继承!
继承中的成员关系:成员变量,构造方法,成员方法
成员变量:
子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致的情况:分别访问即可!
子类继承父类,如果子类中的成员变量名称和父类的成员变量名称一致的情况:
执行流程:
1)现在子类的局部位置中找,如果找到了就使用它
2)如果局部位置中没有,在子类的成员位置中找,如果找到了,就使用!
3)如果找不到,就在父类的成员位置中找,如果找到了,就使用
4)如果还找不到,就报错了,说明访问了一个不存在的变量!
遵循一个:"就近原则"
举例:
public class Demo2 {public static void main(String[] args) {Zi z = new Zi();z.getNum();}}
class Fu{public int num = 10;public int num2 = 30;
}
class Zi extends Fu{public int num2 = 20;public void getNum() {System.out.println(num);//10System.out.println(num2);//20}
}
关于继承中构造方法的关系:
*
* 子类是不能继承父类的构造方法的,但是通过super()来访问父类的构造方法
* 1)在继承中,子类中所有的构造方法都默认访问父类的无参构造方法;
* 相当于子类的所有构造方法的第一句话:隐藏了super();
* 2)为什么,创建子类对象的时候,先执行父类的无参构造方法?
* 因为可能要用到父类中的数据,所以要先让父类中的数据进行初始化(构造方法),
* 父类初始化完毕了,然后才执行子类的构造方法(子类数据初始化)---->分层初始化!
* super():如果在子类的构造方法显示给出了,必须写在第一句,否则可能出现父类初始化多次!(可以省略不写.)
public class Demo2 {public static void main(String[] args) {//创建子类对象Son s = new Son() ;//无参构造创建对象System.out.println("--------------------------");Son s2 = new Son("Java") ;//有参构造创建对象}}
class Father{public Father() {System.out.println("这是父类的无参构造方法");}public Father(String name) {System.out.println("这是父类的有参构造方法");}
}
//定义一个子类
class Son extends Father{public Son() {super() ;System.out.println("这是子类的无参构造方法");}public Son(String name) {super() ;System.out.println("这是子类的有参构造方法");}
}
这是父类的无参构造方法
这是子类的无参构造方法
--------------------------
这是父类的无参构造方法
这是子类的有参构造方法
如果父类的无参构造方法没有提供,那么子类构造会出现什么情况?
* 子类的所有构造方法默认父类的无参构造方法,父类如果没有提供,就报错了!
*
* 如何解决呢?
* 1)手动给出父类的无参构造方法 (之前说在写一个标准类的时候,建议永远给出无参构造方法)
* 2)现在手动不提供无参构造方法,如何解决?
* 2.1)间接的通过super(xx)来访问父类的有参构造初始化!
* 2.2)通过this(),访问本类(子类)的无参构造方法,然后在通过子类的无参构造方法里面super(xx)
* 间接访问父类的有参;
*
* 根据上面的总结:
* 子类中的所有构造方法里面某一个构造方法必须让父类初始化,super(xx),this(),
* 全都是在构造方法中的第一句!
public class Demo2 {public static void main(String[] args) {//创建子类对象Son s = new Son() ;//无参构造创建对象}}
class Father{/*public Father() {System.out.println("这是父类的无参构造方法");}*/public Father(String name) {System.out.println("这是父类的有参构造方法");}
}
//定义一个子类
class Son extends Father{public Son() {super("1") ;System.out.println("这是子类的无参构造方法");}public Son(String name) {this();System.out.println("这是子类的有参构造方法");}
}
这是父类的有参构造方法
这是子类的无参构造方法
this:代表当前类对象的地址值引用
super:代表父类的空间标识(代表父类的对象空间地址值引用)
猫狗案例:
public class Demo3 {/*** 猫狗案例---继承版* 猫类* 属性:姓名,年龄* 行为:吃,睡,特有功能:抓老鼠* 狗类* 属性:姓名,年龄* 行为:吃,睡,特有功能:看门* * 由于存在共性内容,将共性内容抽取到一个独立的类中* Animal类 ----> 父类* 属性:姓名,年龄* 行为:吃,睡 ,提供公共访问的成员方法* 构造方法*/public static void main(String[] args) {Cat c = new Cat(3,"咪咪");System.out.println(c.getName() + c.getAge());//咪咪3c.eat();//猫吃小鱼干c.sleep();//猫白天睡觉c.catchMouse();//猫抓老鼠Dog d = new Dog();d.setAge(5);d.setName("小黑");System.out.println(d.getName() + d.getAge());//小黑5d.eat();//狗吃骨头d.sleep();//狗白天睡觉d.lookDoor();//狗看家护院}}
class Animal{private int age;private String name;public Animal() {super();}public Animal(int age, String name) {super();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;}public void eat() {}public void sleep() {}}
class Cat extends Animal{public Cat() {super();}public Cat(int age, String name) {super(age, name);}@Overridepublic void eat() {System.out.println("猫吃小鱼干");}@Overridepublic void sleep() {System.out.println("猫白天睡觉");}public void catchMouse() {System.out.println("猫抓老鼠");}}
class Dog extends Animal{public Dog() {super();}public Dog(int age, String name) {super(age, name);}@Overridepublic void eat() {System.out.println("狗吃骨头");}@Overridepublic void sleep() {System.out.println("狗白天睡觉");}public void lookDoor() {System.out.println("狗看家护院");}}
day11多态
多态的概念:一个事物在不同时刻的体现(堆内存中对象形式)
多态的前提条件:
* 1)必须有继承关系 (继承的好处第三点作为多态的前提条件)
* 如果没有继承关系,谈不上多态!
* 2)方法重写 ,子类继承父类,将父类的功能覆盖掉,使用子类最具体的功能!
* 举例:动物类的吃和睡不一样,具体的猫和狗类才应该有具体的吃和睡的功能!
* 3)父类引用指向子类对象
* 父类名 对象名 = new 子类名() ; (称为"向上转型")
* 多态的成员访问特点:
* Fu f = new Zi() ;
* 成员变量:
* 编译看左边,运行看左边!
* (等号左边编译通过,说明Fu类存在这个变量;运行看左,访问的是Fu类的变量)
* 成员方法:
* 编译看左边,运行看右边!
* (等号左边编译通过,说明Fu类存在这个方法;运行看右,子类出现了和父类一模一样的方法声明:方法重写)
* 静态的成员方法:
* 编译看左,运行看左!(静态的算不上方法重写,跟类直接相关,随着类的加载而加载!)
* 构造方法:存在继承关系(还是分层初始化)
* 先让父类初始化,然后在是子类初始化!
举例:
public class Demo4 {public static void main(String[] args) {//创建对象:多态的形式//父类引用指向子类对象Fu f = new Zi() ;System.out.println(f.num);f.show();f.function();}}
class Fu{public int num = 100 ;public void show() {System.out.println("show Fu");}public static void function() {System.out.println("function Fu");}}
//子类
class Zi extends Fu{public int num2 = 200 ;public int num = 50 ;public void show() {System.out.println("show Zi");}public static void function() {System.out.println("function Zi");}
}
100
show Zi
function Fu
多态的好处:
* 1)提高了代码的复用性(由继承来保证)
* 2)提高了代码的扩展性(由多态的来保证)
多态的弊端: 不能访问子类的特有功能!
如何解决呢?
* 方案1):创建子类的具体对象来访问子类的特有功能!
* 代码实现角度来说没有任何问题,但是从内存角度考虑:创建一个新的对象,需要在堆内存中
*产生一个空间地址值,耗费空间!
* 方案2):
* 模拟向上转型的方式: 父类引用指向子类对象 Fu f = new Zi() ;向上转型的格式
* 向下转型: 将父类的引用强转为子类的引用! (前提必须有向上转型)
* 格式: Zi z = (Zi)f;
*
public class Demo4 {public static void main(String[] args) {Fu f = new Zi();f.show();//大头儿子Zi z = (Zi)f;z.eat();//爱吃西红柿}}
class Fu{public void show() {System.out.println("小头爸爸");}}
//子类
class Zi extends Fu{@Overridepublic void show() {System.out.println("大头儿子");}public void eat() {System.out.println("爱吃西红柿");}
}
在继承关系中,子类出现了和父类一模一样的方法,这个时候子类会将父类的该功能覆盖掉,将这种现象
称为:方法重写(方法复写/方法覆盖)
继承中成员方法关系问题:
* 子类继承父类,如果子类的成员方法名称和父类的成员方法名称不一致的情况:
* 只要通过子类对象分别调用即可!
* 如果子类的成员方法名称和父类的成员方法名称一致的情况:
* 1)先在子类的成员位置中是否存在该方法,存在,就调用
* 2)如果不存在,在父类的成员位置中找,如果存在,就使用
* 3)如果不存在,父类中没有这个方法,就会报错!(都不存在这个方法)
在有的时候,不能将父类的功能覆盖掉,那么这个时候Java提供了一个关键字:final (状态修饰符)
final:最终的,无法更改的(状态修饰符) 被final修饰的成员方法:该方法不能被子类重写!
final,finally,finalize()的区别?
final特点: 可以修饰类:该类不能被继承!
可以修饰符成员变量:此时变量就是常量! (该变量无论局部变量还是成员变量,只能赋值一次!)
如果该变量是一个基本类型修饰的变量:变量的值不能再改变!
如果该变量是一个引用类型的(Student s = new Student();) 被final修饰了
那么该s对象不能再重新开辟堆内存空间了!(堆内存地址值不能改变了)
修饰成员方法: 该方法被重写
final修饰的变量如果是基本类型,它的值不能再改变!
final修饰的变量如果是引用类型,它的堆内存地址值不能该改变!
java.lang.ClassCastException ,向下转型使用不当,会造成一个运行时期异常-->类转换异常!在向下转型的时候,堆内存的数据类型跟栈内存变量类型不一致!(必须是继承关系才可以)
day12抽象类和接口
1.抽象类
概念:
* 在一个类中,如果该类中存在一个功能,仅仅方法声明,没有方法体(抽象方法),需要将该类定义抽象类.
* 举例:
* 动物--->本身不是具体的(抽象的动物类)
* 动物的吃或者睡应该定义为抽象功能---->必须强制子类必须重写抽象功能!
* 具体的动物:猫,狗等等
*特点:
* 1) 如果一个类中有抽象方法,那么该类一定是抽象类;
* 如果一个类是抽象类,那么该类中不一定存在抽象方法;
* 2)抽象类不能实例化(不能创建对象)
* 3)抽象类不能实例化,如何实例化呢?
* 抽象类需要通过子类进行实例化,父类引用指向子类对象(父类是抽象类):抽象类多态!
* 抽象的父类是通过子类进行实例化,那么如果子类也是一个抽象类,子类也就不能实例化,一定会存在具体的子类
* 4)抽象方法的格式:没有方法体的方法
* 权限修饰符 abstract 返回值类型 方法名(形式参数) ;
* abstract:表示抽象
* 可以修饰类,可以修饰成员方法
* 抽象类 必须强制子类完成的事情!(将抽象类中所有的抽象方法重写)
抽象类的成员特点:
* 1)成员变量: 即可定义一个常量,也可以定义为变量
* 2)成员方法: 既可以定义抽象方法,也可以定义非抽象方法
* 3)构造方法:存在构造方法,既可以有参构造也可以是无参构造方法(作用:对数据进行初始化)
* 抽象类成员方法特点:
* 成员方法如果是抽象方法,必须强制类完成的事情
* 成员方法如果是非抽象方法,子类继承父类--来提高代码的复用性!
如果一个类中没有抽象方法,那么这个类可不可以定义为抽象类呢?有什么意义?
* 1)可以定义.
* 2)意义就是不能直接创建对象!
* 该抽象类中的一些功能的返回值可能就是该类本身!
* 例如(日历类:Calendar它就是抽象类,里面的功能getInstance()非抽象方法,返回值就是该类本身)
abstract关键字不能和哪些关键字共用 (定义成员方法的时候)
和final关键字冲突:final修饰成员方法,不能被重写,冲突了
和private关键字冲突:私有的方法本身不能被继承,冲突了
和static关键字冲突:static修饰的成员方法跟类相关,随着类的加载而加载,show方法是一个抽象方法,没有方体,加载进内存没有意义!
举例:
public class Demo5 {/*** 假如我们在开发一个系统时需要对员工类进行设计，(Employee)(抽象类)* * 程序员类包含3个属性：姓名、工号以及工资。 * 项目经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。(bonus) * * 请使用继承的思想(使用抽象类多态进行测试)设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。* * 分析:* 员工类:Employee ---抽象类* 成员变量:姓名(empName),工号(empId),工资(empSalary)* 构造方法: 无参构造/有参构造方法* 成员方法:setXXX(形式参数)/getXXX()方法* 其他成员方法* work();* * 程序类:Programmer类 继承自 Employee* 无参/有参构造* 重写work方法 --- "程序员没日没夜敲代码"* * 特有功能:* 追求完美* * 项目经理类:Manager 继承 Employee* 特有属性:奖金bonus* 提供针对奖金属性的setXXX(形参)/getXXX()公共访问方法* 无参/有参构造* 重写work方法 --- "吃饭,喝酒,谈项目!"* 特有功能:自己分析* */public static void main(String[] args) {Employee e = new Programmer("张三", "001", 7500);System.out.println(e.getName() + e.getId() + e.getSalary());//张三0017500e.work();//敲代码Programmer p = (Programmer)e;p.play();//玩dotaManager m = new Manager();m.setBonus(2000);m.setId("002");m.setName("李四");m.setSalary(10000);System.out.println(m.getName() + m.getId() + m.getSalary() + m.getBonus());//李四002100002000m.work();//控制项目进度m.play();//玩英雄联盟}}
abstract class Employee{private String name;private String id;private int salary;public Employee() {super();}public Employee(String name, String id, int salary) {super();this.name = name;this.id = id;this.salary = salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getId() {return id;}public void setId(String id) {this.id = id;}public int getSalary() {return salary;}public void setSalary(int salary) {this.salary = salary;}public abstract void work();
}
class Programmer extends Employee{public Programmer() {super();}public Programmer(String name, String id, int salary) {super(name, id, salary);}@Overridepublic void work() {System.out.println("敲代码");}public void play() {System.out.println("玩dota");}}
class Manager extends Employee{private int bonus;public Manager() {super();}public Manager(String name, String id, int salary,int bonus) {super(name, id, salary);this.bonus = bonus;}public int getBonus() {return bonus;}public void setBonus(int bonus) {this.bonus = bonus;}@Overridepublic void work() {System.out.println("控制项目进度");}public void play() {System.out.println("玩英雄联盟");}}
2.接口
接口:体现的是事物的一种扩展性功能.(本身不具备的,经过一些学习才能具备的功能!)
* 举例:猫和狗本身不具备的跳高的功能,经过特殊的训练--->具备这个功能!
* 接口如何表示:interface
接口中的注意事项:
* 1)接口中只能定义抽象方法
* 2)接口不能实例化
* 3)接口如何实例化呢?
* 通过接口的子实现类来进行实例化!
* 格式:接口名 对象名 =new 子实现类名(); 接口多态!
* 接口和子实现类之间的关系:实现关系(implements)
* 一般开发定义接口的子实现类的时候 , 类名: 接口名 + Impl
* 4)接口的子实现类
* 4.1)子实现类不是具体类(抽象类)---->抽象类不能实例化---存在具体的子类
* 4.2)子实现类研究的都是具体类! 因为具体的子实现类可以实例化(创建对象!)
抽象类和接口之间的区别?
成员的区别:
成员变量
抽象类:可以是常量也可是变量
接口:只能是常量: 存在默认修饰符 public static final...
成员方法:
抽象类:可以抽象方法(没有方法体),也可以非抽象方法
接口:只能是抽象方法,存在默认修饰符:public abstract
构造方法:
抽象类:存在构造方法,有参/无参,对数据进行初始化
接口:没有构造方法的!
关系的区别:
类与类:继承extends,支持单继承,不支持多继承,可以多层继承
类接口:实现implements,支持一个类继承另一个类的同时可以实现多个接口
接口与接口:继承extends,支持单继承,也可以支持多继承!
继承:存在一种局限性 ----> 面向接口编程!
设计理念的区别:
抽象类---->继承关系--->体现的是一种"is a"的关系!
接口------>实现关系--->体现的是一种"like a"的关系!
猫狗案例
public class Demo3 {/*** 猫狗案例,加入接口(跳高)* 分析:从具体到抽象* 猫* 属性:姓名,年龄,颜色* 行为:吃,睡,特有功能* 狗:* 属性:姓名,年龄,颜色* 行为:吃,睡,特有功能* 由于存在共性内容--->抽取出来 放在动物类Animal (抽象类)* 属性:姓名,年龄,颜色* 行为:吃,睡(抽象方法)* 猫和狗都继承自动物类* 部分猫和部分狗它能够跳高----->实现接口:跳高 的接口!* 使用面向对象编程方式:代码体现出来,测试对应的猫和狗(底层最具体的类功能实最多!)* 代码实现:从抽象具体* 定义接口--->抽象类--->子类 /子实现类*/public static void main(String[] args) {Cat c = new Cat(3,"咪咪");System.out.println(c.getName() + c.getAge());//咪咪3c.eat();//猫吃小鱼干c.sleep();//猫白天睡觉c.catchMouse();//猫抓老鼠c.jump();//猫上树Dog d = new Dog();d.setAge(5);d.setName("小黑");System.out.println(d.getName() + d.getAge());//小黑5d.eat();//狗吃骨头d.sleep();//狗白天睡觉d.lookDoor();//狗看家护院d.jump();//狗钻火圈}}
interface Jump{public abstract void jump();
}
class Animal{private int age;private String name;public Animal() {super();}public Animal(int age, String name) {super();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;}public void eat() {}public void sleep() {}}
class Cat extends Animal implements Jump{public Cat() {super();}public Cat(int age, String name) {super(age, name);}@Overridepublic void eat() {System.out.println("猫吃小鱼干");}@Overridepublic void sleep() {System.out.println("猫白天睡觉");}public void catchMouse() {System.out.println("猫抓老鼠");}@Overridepublic void jump() {System.out.println("猫上树");}}
class Dog extends Animal implements Jump{public Dog() {super();}public Dog(int age, String name) {super(age, name);}@Overridepublic void eat() {System.out.println("狗吃骨头");}@Overridepublic void sleep() {System.out.println("狗白天睡觉");}public void lookDoor() {System.out.println("狗看家护院");}@Overridepublic void jump() {System.out.println("狗钻火圈");}}
关于形式参数问题的研究(引用类型!)
方法形式参数两种类型:
基本数据类型:形式参数的改变对实际参数没有影响!
引用数据类型:形式参数的改变对实际参数有直接的影响!
具体类:调用该方法,实际参数需要传递该具体类的对象!
抽象类:那么调用该方法,实际参数需要传递该抽象类的子类对象!(其次)
接口:那么调用该方法,实际参数需要传递该接口的子实现类对象!(使用居多)
返回值如果是 引用数据类型
具体类:需要返回该具体类的对象!
抽象类:需要返回该抽象类的子类对象!(其次)
接口:需要返回该接口的子实现类对象!(常见的)
day13内部类以及匿名内部类
1.内部类
Java中访问权限修饰符
* 在本类中 在同一个包下(子类,无关类) 不同包下(子类) 不同包下(无关类)
* private Y
* 默认修饰符 Y Y
* protected Y Y
*
* public Y Y Y Y
*
* public权限最大:其次是 protect和默认修饰符
* 最低的访问权限就是:private
*
* 我们开发中,使用最多:public 和private(封装时候用到!)
内部类:
* 就是在一个类中定义另外一个类!(以后看源码:比如:集合中的迭代器)
* 在A类中定义一个B类,
* 那么将B类就称为A类的内部类,A类就是B类的外部类!
* 内部类是可以访问外部类的成员,包括私有!
内部类的分类:
* 成员内部类
* 在外部类的成员位置定义的类
* 局部内部类
* 在局部位置(外部类的成员方法中)定义的一个类
在测试类中
* 要访问内部类的成员:
*访问方式:
* 外部类名.内部类名 对象名 = 外部类对象().内部类对象();
举例:
public class Demo6 {public static void main(String[] args) {Outer.Inner oi = new Outer().new Inner();oi.show();//20System.out.println(oi.num2);//30}}
class Outer{private int num = 20;class Inner{int num2 = 30;public void show() {System.out.println(num);}}
}
成员内部类它的一些修饰符
* private :能够保证内部类的数据的安全性
* static : 静态的成员内部类
* 被static修饰的成员内部类:
* 它里面的成员方法(可以静态/非静态)只能访问外部类中静态的成员!(必须使用static修饰)
* 在测试类中,访问静态成员内部类的成员方法的时候,访问方式如下:
* 外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
举例:
public class Demo6 {public static void main(String[] args) {Outer.Inner oi = new Outer.Inner();oi.show();//20 30}}
class Outer{private static int num = 20;static class Inner{int num2 = 30;public void show() {System.out.println(num);System.out.println(num2);}}
}
局部内部类:
* 在局部位置定义的类,
* 特点:
* 1)可以直接访问外部类的成员,包括私有!
* 2)在外部类的成员方法中,可以通过创建局部内部类对象来访问局部内部类的成员
* JDK7以前(包含JDK7),局部内部类访问局部变量,局部变量必须加入final修饰,否则报错!
* JDK7以后,局部变量会自动加上final,开发者不需要定义final关键字,为什么要加final?
* 原因: 局部变量的生命周期,随着方法调用而存在,随着方法调用完毕而消失,
*而当前这个局部变量被局部内部类在进行访问(局部内部类对象进行访问),在堆内存中对象不会被立即回收,它还在继续使用这个局部变量,需要将这个变量定义为常量,常驻内存---->以便局部内部类对象对该局部变量的访问!
匿名内部类:它是内部类一种简化方式!
* 格式:
* new 类(可以是具体类,也可抽象类)名/接口名(){
* 重写方法;
*
* };
*
* 匿名内部类的好处:
* 省去了繁杂的代码,不需要定义类里面的子类或者接口的子实现类,写法比较简单!
*
* 匿名内部类的本质就是:继承该类或者是实现了该接口的子类对象!
举例:
public class Demo6 {public static void main(String[] args) {Person p = new Person();p.function(new Student1() {@Overridepublic void study() {System.out.println("学习英语");}});}}
interface Student1{public abstract void study();
}
class StudentDemo implements Student1{@Overridepublic void study() {System.out.println("学习java");}}
class Person{public void function(Student1 s) {s.study();}
}
//学习英语
Object
使用API文档学习相关的类,接口等 这里面常用的方法有哪些?
* (Application Programming Interface:应用程序接口)
* 类:
* Object,Scanner,String,StringBuffer,Integer,Character,BigDecimal
* Date日期类(JDK8: LocalDate),Calendar:日历类 ,Math:数学运算
* Random(随机数生产器),System
* 接口:
* 集合:Collection 单例集合
* List Set
*
* Map 集合
*
*
* java.lang.Object类:
* Object类是所有类的根类,每一个类都继承自Object类
*
* public int hashCode() :
* 了解: 获取该对象的一个哈希码值(理解为地址值)它是通过哈希算法算出来的,不是实际意义地址值;
* 每一个对象的哈希码值一般是不同的!
*
*
* //跟反射有关!
* public final Class getClass() 返回该object运行时类(获取字节码文件对象) 跟Java中反射!
*
* 返回值:Class类 :表示字节码文件对象
* public String getName()
* 通过这个类中静态功能:直接可以获取当前类的"全限定名称"(包名.类名)
day14
Object类:
可通过getClass()方法,获取对象的真实类的名称 输出包名.类名
Object类中的toString方法,一般建议重写toString方法;toString方法的作用,可以更方便的显示属性值
Object中的equal方法,在开发中我们需要比较的是属性值,多以需要重写equal方法.equal只能比较引用数据类型的属性值.
String类:
hasnextXxx:如果扫描仪输入中的下一个标记可以使用
nextXxx()方法:返回Xxx类型的值
nextXxx 将输入的下一个标记扫描为Xxx类型
选择排序算法:
选择排序:
* 使用0索引的元素依次和后面索引的元素比较,小的往前放
* 第一次比较完毕,最小值出现在最小索引处!
举例:
public class Demo7 {public static void main(String[] args) {int[] arr = {11,98,34,27,19,88};paixu(arr);getArr(arr);}public static void paixu(int[] arr){int n = arr.length;for(int i = 0; i < n - 1; i++) {int min = i;for(int j = i + 1; j < n - 1 ; j++) {if(arr[j] < arr[min]) {min = j;}}if(min != i) {int temp = arr[i];arr[i] = arr[min];arr[min] = temp;}}}public static void getArr(int[] arr) {System.out.print("遍历后为[");for(int i = 0; i < arr.length; i++) {if(i == arr.length - 1) {System.out.print(arr[i] + "]");}else {System.out.print(arr[i] + ", ");}}}}//遍历后为[11, 19, 27, 34, 98, 88]