Java基础篇（一）：类与对象--------总结小归纳
JAVA的世界——万事万物皆对象。
一、面向对象概念:
1.万物皆对象；2.将不同类型的数据 抽象出来；
3.重新定义一种事物，起名后，就是一种类型；
4.把数据封装到对象中；
5.使用数据时，使用类的实例；
6.通过调用实例，来使用我们需要的数据。
二、类：
类是对象的模板,对象是类的实例
1.修饰词 classclass className{}
2.成员变量
3.成员方法（方法中也是把数据、属性、逻辑封装起来）
关于方法——最好一个方法只实现单功能
修饰词 返回值类型 方法名 (形参){
方法逻辑......
}
修饰词有:public、protected、default 和private（作用域从大到小）本文中部会画一张表
返回值类型: 1.void() 逻辑结尾可以使用return; 表示方法结束
2.数据类型(基本数据类型或引用数据类型)
一定要使用return 具体数据
对象的实例化：(创建对象)
1.new 构造器(有参传参) 放入堆中
2.类型 变量 = new 构造器(有参传参) (地址传递，值传递)
（声明） （创建新地址--堆中）
属性和方法的访问：(调用)
变量.属性
变量.方法
方法重载：
1.同一个类中；
2.方法名相同，参数列表不同；
3.与参数命名无关，与返回值无关
方法重载的优势：
方法多态
构造方法：(构造器)
1.与类名相同
2.无返回值
3.格式：修饰词 类名(参数列表){
}
作用：类的初始化(对象属性的初始化)
this关键字:
指代一个隐式的引用变量
this.属性------就是当前对象
指向未来要创建的对象。主方法new后的对象 public class Person{
String name;
public Person(String name){ //括号内形参
this.name = name; //形参与实参的传递
}
}构造器也可以重载
this(有参传参)；只能放类里第一行
类的构造器中，调用本类其他构造器，
定义类时，如果不定义构造器，系统默认提供一个无参的构造器
如果定义了构造器，系统取消默认提供的。
三、JVM内存结构（三大部分）
方法区：
加载硬盘上的类文件，读进到方法区 (Person.class)
类的所有信息都在此，包括属性，方法等
堆：
用来存储类的实例(对象)，会给实例分配相应的空间
栈：
存储所有方法的形参，局部变量
在程序运行期间，当执行到某一个方法时，会在栈中
给此方法单独分配一个空间------栈帧
用来存储这个方法包含的所有变量的空间。
方法执行完毕，栈帧消失，释放内存空间。
引用变量，存储的是堆中对象的地址信息。
所以我们引入------JVM垃圾回收机制：
当有指向对象的变量越来愈多时，有可能造成内存溢出，
原因是堆里的对象太多，所以有时要清空变量里的地址信息
String str = "11111";
str = null;
此时，堆里的对象没有任何引用，会被认为是垃圾，被GC(jvm垃圾回收机制)回收
四、继承：
当某一个类的功能不够用时，在不修改此类的基础上将此类的功能扩展到另一个自定义的新类之中
再扩展其他功能。
特点：
1.子类将父类的所有属性和方法都继承下来；
2.如果父类有private属性或方法，在子类中是不可见的(没有访问的权限)
3.子类的特有属性/方法，父类不可访问(我的隐私，老爸不准看)
继承的关键字extends
subClass extends superClass{
}
superClass 父类，也叫基类、超类
五、方法重写：
继承关系，方法名相同，参数列表相同
1.返回值类型：
可相同，也可以(子类方法返回值类型是父类方法返回值类型的子类)
2.修饰词：
可相同，也可以(子类修饰权限大于父类修饰权限)
public>default>protected>private
六、super:
构造方法不能被继承，只能被调用
使用：super(有参传参);
跟前面this();一样，也是只能放到类的第一行。
但是他们倆只能出现其中一种。
七、static:
静态方法：属于类的，应该类名.方法名
Math.random(); //公有资源，谁都可以调。
--（来自于People类）
---------------------------------------------------------------------------------------------------------
--（来自于测试类）
非静态方法：
属于对象，只能用对象调用
静态修饰属性：
也属于类，用类名调用，应该类名.属性名
//公有资源，谁都可以调。
通过某一变量修改后，其他变量使用时都是修改后的数据
静态代码块：
static{
用于加载资源，如图片，视频，音频等
}
静态块执行的时机是加载期间，只执行一次
加载到方法区中。
动态块：{
}
执行的时机是new之前，new一次执行一次。
八、final:
修饰属性：只能进行初始化，不能进行第二次赋值修饰方法：不能被重写
修饰类：不能被继承
static final 一起修饰的变量，就是常量。
九、抽象类：
abstract修饰1.抽象类中可以提供构造器，但是不能被调用
2.可以有属性
3.抽象类里不一定都是抽象方法
4.有抽象方法的类，一定是抽象类
5.抽象方法没有方法体，即没有 {},不能省略abstract，最好使用public修饰
6.只支持单继承，但可以传递
7.抽象类与子类的关系
继承关系，父类可以是抽象类，子类也可以是抽象类。
十、接口：interface
1.默认public修饰，不写也是系统提供2.接口就是一种规范，默认遵守
3.实现类的多继承
特点：
1.不能提供构造器，不能实例化，不被调用
2.接口里的方法一定是抽象方法，一定是abstract public(可省略)
3.接口里的属性，一定是常量
4.接口与接口的关系：可以继承
接口与抽象类的关系：实现关系implements
接口与普通类的关系：实现关系implements
十一、内部类：
当类中需要使用一些数据，不会在其他类中使用，但使用的较为频繁，可定义为内部类
成员内部类：
内部类对象，一般在外部类中使用，
内部类中可以直接访问外部类的成员(私有也可访问)。
原因----有隐式的引用
匿名内部类：最常用
1.隐藏的名字，不显示
2.在方法里写
3.写法如下：
方法重写
};
public class Inner1 {
public void sum(int a , int b){
System.out.println("Inner1的sum方法"+a+b);
System.out.println(a+b);
}
}/*
* 匿名内部类
* 父类|抽象类|接口 变量 = new 父类|抽象类|接口(){
方法的重写
};
*/
public class TestInner extends Inner1{
public static void main(String[] args) {
Inner1 a1 = new Inner1();
a1.sum(5, 6);
Inner1 a = new Inner1(){
@Override //重写后的方法sum()，方法体里可以改新逻辑
public void sum(int a, int b) {
super.sum(a, b); //调用父类的sum(),也可以加别的新东西
}
};
a.sum(3, 4);
}
}
运行的结果是：
Again，再来一个匿名内部类：
/*
* Employee接口，模拟人在单位
*/
public interface Employee {
void work();
}/*
* Family接口，模拟人在家
*/
public interface Family {
void cook();
void sleep();
}
public class Person implements Family,Employee{
@Override
public void work() {
System.out.println("Working只能工作");
}
@Override
public void cook() {
System.out.println("在家能做饭");
}
@Override
public void sleep() {
System.out.println("在家能睡觉");
}
}public class Test {
public static void main(String[] args) {
//匿名内部类的实例
Family Leo = new Family() {
@Override
public void sleep() {
System.out.println("Leo就不睡觉，起来High");
}
@Override
public void cook() {
System.out.println("Neil负责做饭，Leo负责吃");
}
};
Employee Neil = new Employee() {
@Override
public void work() {
System.out.println("Neil上班，老老实实调代码");
}
};
Leo.cook();
Leo.sleep();
Neil.work();
}
}
可见，Leo比较皮，在家天天happy，还要等Neil回来做饭
Neil就比较老实了，加班加点敲代码
总结：
面向对象的特征：1.封装：
一块代码的封装---方法
方法和属性的封装---类
某些数据的封装---对象
优点：
安全性高，一次封装，到处使用，代码维护性高
2.继承：
优点：扩展性高，重用性强
3. 多态：
方法的多态；方法的重载与重写
对象的多态：向上转型与向下转型
（1）.向上转型：父类型的对象引用子类型的对象，子转父
（会丢失精度）
Dog g = new Animal();
g.shout();
（2）.向下转型：子类型的对象引用父类型的对象，(强制转换) (可用方法变多)
Animal a = 子类对象(最好是Dog的对象,否则匹配异常)
Dog g = (Dog)a;----向下转型
验证类型是否匹配： 对象 instanceof 类型
属于：返回true 不属于：返回false
if(a instanceof Dog){
Dog g = (Dog)a;
}
if(a instanceof Cat){
Cat g = (Cat)a;
}