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]