unit2 面向对象
1.面向对象特点：封装 继承 多态
面向对象强调结果 面向过程强调步骤
2.类与对象：对象是具体的实体（行为+属性），类是抽象的模板（成员方法+成员变量） ，类是对象的模板，对象是类的实例
作用在psvm里面的： 导包--创建对象--使用：
import cn.itcast.first.demo06.Student;//导包
Student stu = new Student();//创建对象
System.out.println(stu.age);//使用对象成员变量，此时age属性在domain层里
stu.eat();//使用对象成员方法，此时eat方法在service层里
成员变量：直接定义在类中的，在方法外，有默认值，堆内存，随着对象的创建回收而诞生和消失
局部变量：定义在方法内，无默认值，栈内存，随着方法的进栈出栈而诞生和消失
成员变量：属性 成员方法：行为
成员方法：public void run(){...} 不用写static
内存划分：栈 堆 方法区
下列是一个对象使用一个方法
下列是两个对象使用一个方法
下列是亮两个引用指向同一个对象的空间
使用对象的类型作为方法参数： 使用对象的类型作为方法返回值：
封装性：核心思想，一个方法就是一种封装，调用方法就玩了，为了隐藏内部细节
3.private关键字：保护本成员变量，提高安全性
private int age;
//用private关键字将需要保护的成员变量进行修饰，但是private只能在本类内直接访问，超出则报错
//间接访问private变量，就是定义一对set和get方法
public void setAge(int num){ age = num;}
public int getAge(){ return age;}
//对于setter而言，不能有返回值，参数类型和成员变量对应
//对于getter而言，不能有参数，返回值类型和成员变量对应
4. this关键字：成员变量和局部变量重名时，就近原则，优先访问局部变量
this.name = name; this.成员变量名====调用局部变量名
//this用来区别成员变量和局部变量，避免变量重名，通过谁调用的方法，谁就是this
5.构造方法：
6.构造方法也是可以进行重载的Overlord
定义标准类：
补充：this.num就是在运用本类的一个对象。方法重载同名字不同参数也即是构造方法的重载。
API：application programming interface，应用程序编程接口
快捷键： Alt+Insert------generate-------Getter and Setter///////toString/////////Constructor无参构造，全参构造
//set往里放，有参数无返回
public void setAge(int num) { }
//get往外拿，有返回无参数
public int getAge() {return age;}
-------------------------------------------------------------------------------------------
unit3 类的学习
1.Scanner类：实现键盘输入数据，到程序中
导包：import java.util.Scanner; 只有java.lang包下的内容不用导包，其余全要
创建：Scanner sc = new Scanner(System.in); 里面参数：System.in,代表键盘输入
使用：int num = sc.nextInt(); String str = sc.next();
2.匿名对象：
只有右边的对象，即没有左边的名字和赋值运算符。
当对象对方法仅进行一次调用的时候，就可以简化成匿名对象.
对象只能使用唯一一次，下次再用需要重新创建
例子：new Car().run()； new Person().name = "sjw";
匿名对象作为方法的参数：
3.Random类：生成随机数
导包：import java.util.Random; 只有java.lang包下的内容不用导包，其余全要
创建：Random r = new Random();
使用：int num = r.nextInt(); String str = sc.next();
例子：生成指定范围的随机数：
int num = r.nextInt(3); // [0,3) 左闭右开：0,1,2，
4.对象数组：一旦创建，程序运行期间长度不可以改变
array[1]，地址值 .getName()，数值
ArrayList数组：一般数组长度不可以改变，但是她可以！
ArrayList<E>，泛型，装在集合中的所有元素都是统一 的类型，长度可变，引用类型数据。泛型只能是引用类型，不能是基本类型。
创建：ArrayList<String> list = new ArrayList< >(); 打印的是内容，而不是地址值，如果内容为空，就是[ ]
添加：list.add("sjw"); 对于ArrayList的add（），添加的动作一定是success的，boolean=true
泛型只能是引用类型，不能是基本类型。单是也可以进行转换的，见下：
自动装箱：基本类型-->包装类 反之自动拆箱
5.String类：
StringPool（字符串常量池） ，双引号直接写入到的，new的不是，存放于堆中
==：对于基本类型是数值比较 对于引用类型是地址值比较
方法：
内容比较：equals()
内容获取：
字符串截取：
字符串转换：
字符串拆分成char[]数组：
char[] chars = "hello".toCharArray();
字符串拆分成byte[]数组：
byte[] bytes = "sjw".getBytes();
字符串转换回卷：
String lang = short.replace("去死"，"**");
字符串分割：
6.static关键字：静态方法与对象无关，只与类有关，只要是本类对象，共享同一份；不能有this，super
没有的话，是“类名.方法名（）” 有的话，是“方法名（）”
静态代码块：首次执行时候，有且只能执行唯一一次，可以一次性对static成员变量赋值
7.Arrays类：数组工具类，提供了大量静态方法，实现数组的常见的操作
8.Math类：数学工具类
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
unit4 继承
1.类的继承，覆盖重写：继承是多态的前提，继承就是为了“共性抽取”
子类 extends 父类 { } 方法覆盖重写：@Override。此注解起到安全监测作用。创建子类对象，优先用子类的。
成员变量重名： 成员方法重名：
super关键字：调用父类的变量 super.num
this关键字：调用本类的变量 this.num
@Override：覆盖重写，名称一样，参数列表一样，用于继承类，此注解是可选的安全检测手段
@Overlord：方法重载，名称一样，参数列表不一样
所以，继承用于对父类的拓展，重复其中的共性，添加改动新内容
super：访问父类
this：访问本类
2.抽象：如果父类当中的方法不确定如何进行（）方法的实现，他就是一个抽象方法
abstract关键字，本身没有方法体，除非他被重写
子类 extends 父类 { 覆盖重写父类方法 } 不可以new对象，要创建子类对象使用
//抽象方法 public abstract void eat();
//普通方法 public void normal(){}
3.接口：公共的规范标准，引用数据类型，最重要的是里面的抽象方法
接口定义的任何字段都是static和final的，接口定义的方法也必须是public 和 abstract 的
例子四个：抽象方法，默认方法，静态方法，私有方法，成员变量：常量
public class Impl implements InterFaceTest {
//接口使用：对于抽象方法，要有实现类Impl，Alt+Insert，选中Implements,完成了抽象方法的覆盖重写 @Override
public void method() { System.out.println("first"); }
A：默认方法：public default void 方法()，解决接口升级
B：静态方法：public static void 方法()，带上方法体
C：私有方法：private void 方法()
D：常量定义：成员变量，必须使用 public static final String name = "sjw"; 来修饰
E：补充：
类和接口：类之间单继承，类与接口之间多实现，接口之间多继承
4.多态：extends继承或者implements实现，都是多态的前提，polymorphism=mutil
提升代码的可拓展性，继承和接口是多态的前提
new的是对象，很多的对象体现了多态，用法是：父类引用指向子类对象，左父右子就是多台
会用到：向上转型，向下转型
例子：我，是学生，是女儿。我没变为父，学生和女儿角色在变为子
Fu obj = new Zi();//使用多态,左边父类引用指向子类对象
if(fu instanceof Zi){//采用向下转型，才可以调用子类自己的方法
Zi zi = (Zi) fu;
zi.methodZi();
}
成员变量：
成员方法：
使用：new谁优先用谁，没有则向上找；编译看左边，运行看右边
好处：无论右边new的时候换成哪个子类对象，左边用的父类的方法都不用改变，节省了代码书写
向上转型：就是多态的用法，小--->大，自动的安全的------Up a = new UpZi();
向下转型：还原动作，大---->小，类似于强制类型转换------UpZi b = (UpZi) a;
ps:会出现类出错异常：ClassCastException
5.instanceof关键字：向下转型一定要有instanceof判断，不然发生类转换异常
6.final关键字：修饰类，成员方法，局部变量，成员变量
类：public final class A 当前类不可以有任何子类
成员方法：public final void B(...) 不可以被子类覆盖重写 不可以和abstract同时出现
局部变量：final int c = 10; 一次赋值终生不变 对于基本类型是数值，对于引用类型是地址值
成员变量：public final String name； 加上final之后必须手动赋值才可以，要不直接赋值，要不通过构造方法赋值
//final int n = 10;
// 报错，局部变量加上final之后，
// 有且只可以写一次，即使第二次赋值都一样也报错
//如果FinalFu类是final类，则FinalZi是不可以继承Fu的
public class FinalZi extends FinalFu{
//报错，原来父类方法是final，现在子类方法是不可以覆盖重写的 }
7.四种权限修饰符：public 》 protected 》 （default） 》private ？是否可以访问
同类 √ √ √ √
同包 √ √ √
不同包子类 √ √
不同包非子类 √