使用java实现面向对象编程

第一章（抽象和封装）
1.快捷键
main + alt+/ 快速生成main方法
syso + alt+/ 快速生成输出语句
new了一个类之后。未导入包的话 ctrl+shift+o 快速导入包
alt+shift+s 然后选择getters and setters 就可以快速
生成 set 方法 get 方法 封装

2.方法重载
public void print(){}
public void print(int i){}
public void print(int i,string b)
public void print(string b,int i)
方法重载就是： 在同一个作用域（同一个类）中方法名称一样。但是参数的个数或者数据类型。或者顺序不一样的方法。
就是方法重载


第二章 （继承）
1.继承的关键字
类名 extends 要继承的类名
2.可以继承的东西
（1）public和protected修饰的属性和方法。不管子类和父类是否在同一个包里
(2)继承默认权限修饰符修饰的属性和方法。但子类和父类必须在同一个包里。
（3）无法继承private修饰的属性和方法。
(4)无法继承父类的构造方法
(5)void test(); 缺省的。 缺省作用域修饰的属性和方法。在同一包中的类可以继承和调用，不同包中的类无法继承和调用

(6).4个作用域修饰符
访问修饰符 本类 同包类 子类 其他类
private 可以
缺省的(friendly) 可以 可以
protected 可以 可以 可以
public 可以 可以 可以 可以

3.继承构造方法的顺序
public class test1 {
public test1(){
System.out.println("test1");
}
}
public class test2 extends test1{
public test2(){
System.out.println("test2");
}
}
public class test3 {
public static void main(String[] args) {
test2 t = new test2();
}
}
输出 test1 然后输出test2 ; 继承父类之后。会先执行父类的构造方法，然后执行子类的构造方法,
因为子类构造方法没写明super; 于是自动调用super.从而调用了父类的无参构造方法

4. super .继承条件下构造方法的调用规则.
(1)如果子类构造方法没有写super 显示调用父类的有参构造方法。也没有通过this显式调用自身其他构造方法。择会默认先调用
父类的无参构造方法。在这种情况下。写不写super效果都一样!!!!!
(2)如果子类构造方法通过super 显示调用父类的有参构造方法,那将执行父类相应的构造方法。而不会执行父类无参构造方法
(3)如果子类构造方法中通过this显式调用自身其他构造方法。在相应构造方法中应用 1 和 2 两条规则
(4)特别注意的事。如果存在多级继承关系。在创建一个子类对象时。以上规则会多次向更高一级父类应用。一直执行到父类
object类的无参构造(注：什么都没有)方法为止

super() //调用直接父类无参构造方法
super.name //调用直接父类的某个属性值
super.print() //调用直接父类的某个方法
注意： super调用父类构造方法必须是在第一句

public abstract void print(); //不用写方法声明
子类如果继承了父类。 则必须实现这个方法。 否则报错！

6.final 不可更改。！
(1)用final 修饰的类不能再被继承
final class
(2)用final 修饰的方法不能被子类重写
public final void print(){}
(3)用final 修饰的变量将变成常量。只能赋值一次
final String = "南极";
//注意 。值类型变量。值不可更改。引用类型变量 。如一个类。是引用地址不可更改。但是此类的属性可以更改！！！


第三章 （多态）
1.子类转换成父类的规则
(1)将一个父类的引用指向一个子类对象。称为向上转型（upcasting）。自动进行类型转换
如 Pet p = new Dog();
(2)此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法。不是父类的方法
如 p.eat(); 将执行 Dog类的eat() 方法.
(3)此时通过父类引用变量无法调用子类的<<<特有方法>>>。必须进行类型转换！

2.使用父类作为子类继承父类的方法的参数从而实现多态.
把父类座位方法参数是使用多态的常用方式.

3.类型转换
Pet p = new Pet(); //父类 pet
Dog d = (Dog)p; //向下转型。 必须进行转换才可以调用dog类的特有方法
d.catchingFlyDisc(); //调用玩游戏的方法
Penguin pgn = (Penguin)p; //出现转换异常错误。 因为此时pet 是dog 。

4.instanceof 等同于 C#的 is
(1)Pet对象 instanceof dog 判断成功返回真 否则返回假 等同于Pet对象 is dog
(2)使用时 要判断的两个对象必须有继承关系 。 否则编译错误。
(3)数据类型转换失败不会报错。 会赋null值。提高代码健壮性;

5.迭代。 等同于C#的 forecah
for(MotoVehicle mv : mvs){}

6.继承的时候，父类的被继承的方法被继承到子类之后，不能缩小作用域，只能扩大作用域

第四章 （接口）
接口是一种约定。一种能力。 与抽象类 类似.
1.接口的声明和使用
(1)[修饰符] interface 接口名 [extends 父接口。。]{
常量定义。
方法定义.
}
public interface iUSB {}
(2)class 类名 extends 父类名 implements 接口1,接口2 {
}
public class usbI implements IUSB


2.接口的重要注意点。
(1).接口中值能定义常量。接口中的属性都会自动用public static final修饰。 即接口中的属性都是全局静态变量。必须在定义时指定初始值
public static final int pi = 3.14 等同于接口中的 int pi = 3.14
(2).接口中的所有方法都是抽象方法。接口中方法都会自动用public abstract修饰。即接口中只有全局抽象方法
public abstract void show() 等同于接口中的 void show()
(3).和抽象类一样。 接口不能实例化。接口中不能有构造方法.
(4).接口之间可以通过extends继承。一个接口可以继承多个接口。但接口不能继承类
(5).一个类只能有一个直接父类。但可以通过implements实现多个接口。类必须实现接口的全部方法。否则必须定义为抽象类。
类在继承父类的同时又实现了多个接口时。extends必须位于implements
(6). 接口不能实例化.
public interface it{}
测试类中： it i = new it(); 报错。 无法实例化。 等同于抽象类概念

3.接口表示一种约定
(1)即用接口作为参数。 具体可以参考继承的 拿父类作为参数. 类似.
4.接口表示一种能力
（1）一个类实现了一个某个接口，就表示这个类具备了那种能力。
就好像玩游戏。 有很多技能。 你学习了某种技能。 你就能用这个技能了。 具备这种能力了。

5.java 接口与 C#接口的对比
(1).java 通过extends继承父接口。类通过implements实现接口.C#通过 : 实现这两个功能;
(2).java 接口中的成员变量（属性）必须是常量。自动用public static final修饰。C#中不允许存在成员变量。但是可以有属性，不能包含
常量。变量。构造方法和任何静态成员
(3).java接口中属性和方法都可以使用public 修饰。C#中默认public 。不允许显式使用public 修饰
(4).java接口可以定义静态常量和方法,C#中不允许


第5章
1.生成随机数
import java.util.Random; //导入此类
Random r = new Random();
r.nextInt(5); //生成0到4的随机数 小于这个参数

2.static 深入使用。
public final static Level[] levels = new Level[6];
static{
levels[0] = new Level(1,2,10,30,1);
}

(1).以上代码是用static 修饰的代码段. 当类被载入的时候（类第一次被使用到的时候载入。）执行static代码段.
且只执行一次。主要作用是实现static属性的初始化.

3.获取当前时间的毫秒数
long currenTime = System.currentTimeMillis();

4.立即退出程序.
System.exit(1);

5.获取当前类的对象引用
Game g = new Game(this);

第6章
1.instanceof
判断某个对象是否是与一个类或者实现了一个接口。 接口为true 或 false
如下代码案例 其中 cat 和 Dolphin是子类，Animal是父类,cat实现了Terrestrial接口
Cat c = new Cat("加菲猫",4);
Dolphin d = new Dolphin("海豚奇奇");
System.out.println(c instanceof Cat); //true
System.out.println(c instanceof Animal);//true
System.out.println(c instanceof Terrestroal); //true
System.out.println(d instanceof Terrestroal); //false
System.out.println(c instanceof Dolphin); //编译错误