在面向对象阶段，学习了面对对象的方法、类和对象、成员变量、局部变量、静态常量、构造方法、面对对象的三大特性（封装、继承、多态）、OBject类、访问修饰符、final关键字、抽象类（abstract）、接口类interface、static。
类和对象
类（class）：具有相同属性和行为的独享的集合。
方法：描述对象的动作，在程序中，通过定义变量的像是表现属性
属性：描述对象的特征
定义类：
[修饰符] class 类名{
//属性（变量）
//行为（方法）
}
public class Car {
//定义属性
String brand;//品牌
String color;//颜色
int seat=5;//座位数
//定义行为
void go(){
System.out.println("在行驶");
}
void stop(){
System.out.println("停下来了");
}
void fly(){
System.out.println("飞起来了");
}
}创建对象
类名 对象名=new 构造方法（[参数]）；
创建对象，通过"."操作符访问类中的非私有属性和方法
/*
* 创建工厂类(程序入口)，该类可以创建车的对象
* */
public class Factory {
public static void main(String[] args) {
//类名 对象名 = new 类名([参数]);
//创建车类的对象c1
Car c1 = new Car();
//给对象的属性赋值
c1.brand = "宝马";
c1.color = "白色";
System.out.println("车名：" + c1.brand + "，颜色：" + c1.color + ",座位数："
+ c1.seat);
c1.go();
c1.fly();
c1.stop();
Car c2 = new Car();
c2.brand = "五菱宏光";
c2.color = "黑色";
c2.seat = 7;
System.out.println("我有一辆" + c2.seat + "座的" + c2.color + c2.brand);
}
}类和对象的关系
对象是类的具体表现，类是对象的集合（模板）
先定义类，才能通过该类创建对象
成员变量、局部变量、静态常量
成员变量
定义在类中的变量，称为成员变量，拥有默认值
成员变量随着对象的创建而存在没随着对象的回收而销毁。作用范围在类内部。成员变量有初始值。
public class Car{
String brand;//这就是一个成员变量，默认值为null
void info(){
//这里brand虽然没有赋值，但是它是一个成员变量，属于引用类型，默认值为null
System.out.println("车名："+brand);//如果不赋值，最终打印"车名：null"
}
}局部变量
定义在方法中的变量，称为局部变量。默认没有默认值，赋值之后才能使用
局部变量随着类的加载而存在，随着方法的执行结束而销毁。作用范围在方法内部。
public class Test{
public static void main(String[] args){
//这里的num和name就是一个局部变量,没有默认值
int num;
System.out.println(num);//这里无法通过编译，因为num没有赋值
String name="小明";
System.out.println(name);//这样才能正常输出
}
}静态常量
被final、static修饰的成员变量
静态常量随着类的加载而存在，随着类的销毁而销毁。作用范围在程序周期中。静态常量有初始值
构造方法
它是一个特殊的方法，没有返回值，方法名和类名一致，每一个类在定义时，都有一个默认隐藏的无参数的构造方法，在创建对象时调用。构造方法通常用于初始化成员变量。
public class 类名{
//这是无参构造方法，默认就会存在，不过是隐藏的
public Test(){
}
}特点：
构造方法没有返回值(没有返回值这一部分，不是void)，构造方法名必须和类名相同
每个类默认有一个隐藏无参数的构造方法，方法体中没有内容，用于创建无参数的对象
三大特性：封装、继承、多态
封装
继承
方法重写Override
当子类继承父类后，可以对父类中的非私有的方法进行扩展或覆盖，这个过程称为重写。
要求：
方法名、参数列表、返回值必须和父类一致
访问权限不能比父类更严格
不能抛出比父类更大的异常
方法重载overload
在一个类中，多个方法的方法名相同，参数列表不同时，这些就是重载的方法。即同名不同参
要求
方法名相同
参数列表（类型和数量）不同
与返回值无关
this和super关键字
可以当作对象使用，也可以当作构造方法使用
当对象使用："this.属性"或"this.方法"或"super.属性"或"super.方法"
此时的this或super表示“当前类”或“父类对象”
public calss Person{
private String name;
public void setName(String name){
this.name=name;//这个this表示当前类Person的对象
}
}当构造方法用："this([参数])或super([参数])"
public class Person(){
private String name;
private int age;
public Person(){
//这句话表示调用Person(String name,int age)构造方法，只能放在第一行
this("小明",20);
}
public Person(String name,int age){
this.name=name;
this.age=age;
}注意
Object类
它是所有类的父类，任何类都可以间接地继承了该类，但没有明确的在extends中体现出来。所有类都可以访问Object类中的方法，或对其进行重写。
向上转型
Person p = new Person();
Object obj=p;向下转型
Animal an = new Animal();
Cat c=(Cat)an;多态
public class Father{
}
public class Son extends Father{
}
public class Main{
public static void main(String[] args){
Son son = new Son();
//这就是多态的体现
//子类的对象，可以使用父类的变量保存
Father father = new Son();
}
}访问修饰符
访问权限表
final关键字
用于修饰属性、方法和类 。当final修饰属性时，该属性的值不可更改。
修饰属性：变量成常量，不能改变其中的值。
修饰方法：方法称为最终的方法，不能重写。
修饰类：类称为最终类，不能被继承。
在属性前加上final，这时的属性称为常量。常量命名时，所有字母都要大写，多个单词用_隔开。
final 数据类型 常量名；
final NUM=123;修饰方法：该方法不能被重写。在返回值前面加上final
public class Father{
public final void fun(){
}
}修饰类时，该类不能被继承，在class前面加上final
public final class Father(){
}
//提示错误，该类不能被继承
public class Son extends Father{
}抽象类（abstract）
修饰方法： 访问修饰符 abstract 返回值类型 方法名（参数类型 形参名称）；
//当一个类中有抽象方法时，该类也需要是一个抽象类
public abstract class Game{
//这就是一个抽象方法，没有方法体
public abstract void startGame(Player player);
}修饰类： 访问修饰符 abstract class 类名{}
如果一个类中有抽象方法，这个类必须也是一个抽象类。
抽象类不能被实例化(不能创建对象)。
抽象类中，可以存在非抽象方法，如getter/setter或构造方法。
当抽象类的构造方法执行时，不会创建对象。
接口interface
public interface 接口名{
//接口中只能定义公开的静态常量且要赋值，默认用public static final修饰
double PI = 3.14;
//接口中的方法默认用public abstract修饰，表示公开的抽象方法
void fun(String name);
//接口中不能定义普通方法
//void fun1(){}
//jdk1.8之后，接口中可以定义默认方法或静态方法，有方法体
defult void fun2(){
}
}static （静态的）
是一个修饰符，可以修饰属性、方法、代码块。
被static修饰的内容，被称为静态成员。静态成员在类加载的时候，就会保存到内存中，可以脱离对象存 在。 所以访问静态成员时，可以不用创建对象，直接通过类名访问。
特点
静态方法中只能使用静态成员，不能使用非静态成员。
非静态方法中可以使用静态成员。
静态方法中，不能使用this关键字。
318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
