最近一直在追Java写博客，如有问题欢迎添加QQ：1776136546（微信同步）。
1.类的继承
关键字：extends
package st.peter.obj2; public class Animal { String name; public void shout() { System.out.println("动物发出叫声"); } } package st.peter.obj2; public class Dog extends Animal{ public void printName() { System.out.println("name="+name); } } package st.peter.obj2; public class Demo1 { public static void main(String[] args) { Dog dog = new Dog(); dog.name = "哈士奇"; dog.printName(); dog.shout(); } }子类在继承父类的时候，会自动拥有父类的所有成员。
Java中类只支持单继承，不容许多重继承。
重写：
子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
package st.peter.obj2; public class Animal { String name; public void shout() { System.out.println("动物发出叫声"); } } package st.peter.obj2; public class Dog extends Animal{ //重写父类的方法 public void shout() { System.out.println("汪汪汪......"); } } package st.peter.obj2; public class Demo1 { public static void main(String[] args) { Dog dog = new Dog(); dog.shout(); } }super关键字：
super关键字用来访问父类的成员。访问父类的成员变量，成员方法和构造方法。
（1）：super关键字调用父类的成员变量和成员方法
package st.peter.obj2; public class Animal { String name = "动物"; public void shout() { System.out.println("动物发出叫声"); } } package st.peter.obj2; public class Dog extends Animal{ String name = "犬类"; //重写父类的方法 public void shout() { super.shout(); //调用父类的成员方法 } public void printName() { System.out.println("name="+super.name); //调用父类的成员变量 } } package st.peter.obj2; public class Demo1 { public static void main(String[] args) { Dog dog = new Dog(); dog.shout(); dog.printName(); } }
（2）：使用super关键字调用父类的构造方法
package st.peter.obj2; public class Animal { public Animal(String name) { System.out.println("name="+name); } } package st.peter.obj2; public class Dog extends Animal{ public Dog() { super("hahah"); } } package st.peter.obj2; public class Demo1 { public static void main(String[] args) { Dog dog = new Dog(); } }
2.final关键字
final修饰的类不能被继承
final修饰的方法不能被子类重写
final修饰的变量是常量，只能赋值一次。
3.抽象类和接口
（1）抽象类
Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。
当一个类包含了抽象方法，该类必须使用abstract关键字来修饰。
抽象类不能用来实例化，如果想要调用抽象类中的方法，则需创建一个子类，在子类中将抽象类中的抽象方法进行实现。
package st.peter.obj2; public abstract class Animal1 { //定义抽象方法 abstract void shout(); } package st.peter.obj2; public class Dog extends Animal1{ @Override void shout() { // TODO Auto-generated method stub System.out.println("汪汪汪。。。。。。"); } } package st.peter.obj2; public class Demo2 { public static void main(String[] args) { Dog dog = new Dog(); dog.shout(); } }
（2）接口
接口中定义的方法默认使用“public abstract”来修饰。
接口中的变量默认使用“public static final”来修饰
需要定义一个类，通过关键字“implements”实现接口中的所有方法。
package st.peter.obj2; public interface Ani { int ID = 1; void breathe(); void run(); } package st.peter.obj2; public class Dog1 implements Ani { @Override public void breathe() { System.out.println("狗在呼吸！"); } @Override public void run() { System.out.println("狗在跑！"); } } package st.peter.obj2; public class Demo3 { public static void main(String[] args) { Dog1 dog = new Dog1(); dog.run(); dog.breathe(); } }接口之间可以继承，可以单继承，也可以双继承。
4.多态
在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。
package st.peter.obj3; public interface Animal { void shout(); } package st.peter.obj3; public class Dog implements Animal{ @Override public void shout() { System.out.println("狗在叫......"); } } package st.peter.obj3; public class Cat implements Animal{ @Override public void shout() { System.out.println("猫在叫......"); } } package st.peter.obj3; public class Test1 { public static void main(String[] args) { Animal a1 = new Cat(); //将Cat对象当做Animal类型来使用 Animal a2 = new Dog(); animalShout(a1); animalShout(a2); } public static void animalShout(Animal ani) { ani.shout(); } }对象类型转换-强转
package st.peter.obj3; public interface Animal { void shout(); } package st.peter.obj3; public class Dog implements Animal{ @Override public void shout() { System.out.println("狗在叫......"); } public void run() { System.out.println("狗在跑！"); } } package st.peter.obj3; public class Test1 { public static void main(String[] args) { Dog dog = new Dog(); animalShout(dog); } public static void animalShout(Animal ani) { Dog dog = (Dog)ani; dog.shout(); dog.run(); // ani.shout(); // ani.run(); } }Java提供了一个关键字instanceof,判断一个对象是否为某个类（接口）的实例或者子类实例。
package st.peter.obj3; public interface Animal { void shout(); } package st.peter.obj3; public class Dog implements Animal{ @Override public void shout() { System.out.println("狗在叫......"); } public void run() { System.out.println("狗在跑！"); } } package st.peter.obj3; public class Cat implements Animal{ @Override public void shout() { System.out.println("猫在叫......"); } } package st.peter.obj3; public class Test1 { public static void main(String[] args) { //Dog dog = new Dog(); //animalShout(dog); Cat cat = new Cat(); animalShout(cat); } public static void animalShout(Animal ani) { if(ani instanceof Cat) { Cat cat = (Cat)ani; cat.shout(); }else { System.out.println("是狗不能强转为猫"); } } }Object类
他是所有类的父类，即每个类都直接或间接继承自该类
匿名内部类
匿名内部类的格式：
new 父类（参数列表）或父接口（）{
//匿名内部类的实现部分
}
package st.peter.obj4; public interface Animal { void shout(); } package st.peter.obj4; public class Test1 { public static void main(String[] args) { //定义匿名内部类作为参数传递给方法 animalShout(new Animal() { @Override public void shout() { System.out.println("动物在叫"); } }); } public static void animalShout(Animal ani) { ani.shout(); } }
5.异常
语法格式如下：
try{
//程序代码块
}catch(ExceptionType e){
//对Exception的处理
}
try代码块中编写可能发生异常的Java语句。在try代码块中发生异常语句后面的代码是不会执行的。
catch代码块中编写针对异常进行处理的代码。
在程序中，有时候我们希望有些语句无论程序是否发生异常都要执行。加一个finally代码块。
package st.peter.obj4; public class Test2 { public static void main(String[] args) { //try ... catch ... finally 用于捕获异常 try { int result = divide(4,0); System.out.println(result); }catch(Exception e) { System.out.println("捕获的异常信息为："+e.getMessage()); return; //结束当前的方法，System.out.println("程序继续向下执行");不会执行 }finally { System.out.println("finally代码块。。。"); } System.out.println("程序继续向下执行"); } public static int divide(int a,int b) { int result = a/b; return result; } }throws关键字
编译时异常与运行时异常
自定义异常
6.包
import语句
7.访问控制
访问控制级别
