1::一个java文件中可有多个类,但是只能有一个类被声明为public ,并且只能以这个共有类来作为该java文件的名称
2:final修饰一个类的方法,则该方法不能被重写,final 修饰属性,则该属性只能被赋值一次,顾名思义,final为之后的一次
3:final修饰变量,该该变量相当于常量,不能多二次赋值
常量的真正的修饰方式为static final
4:java中常量的命名规则为是,常量名都大写,多个单词之间以下划线拼接,如:static final PI = 3.141592657;
5:inal 修饰参数,则该参数在方法体中不能被修改值
6:多态三要素1:父类引用指向子类,2,:继承,3:重写
父类引用指向子类,则该引用只能看到父类中的方法,这种现象称为萎缩,
如果该父类的方法被子类重写了,则该引用指向的方法会直接先调用子类的方法,而不能执行父类的方法,这是
一个意外啊;
7:抽象方法不能有实现,并且包含抽象方法的类必须声明为抽象类,抽象的含义是:一个有规划,未完工的,他需要被继承来实现,抽象类渴望被实现,不能被实例化,(这与final相反,final不能被继承,但是可以被实例化),但是无论是普通的类还是抽象类,或者final类,都能作为引用变量,抽象方法可以抽象的理解为:父债子还,父亲欠的债,无力偿还,这也就符合抽象方法的含义,没有实现(不等同于空实现),这个父亲的类是残缺的,不能被实例化,只能通过子类来继承自己并且必须实现父亲中未实现的方法,既还债的方法,子类中重写父类的抽象方法,抽象类有主动抽象,既任何的一个类,都能声明为抽象类,不能实例化,必须通过继承来实现
代码片段如下
- <span style="font-size:18px">public class Human {
- public void name(){
- System.out.println("I'm human!!!!");
- }
- public void run(){
- System.out.println("Human is running...");
- }
- public void eat(){
- System.out.println("I'm human");
- }
- public void swinming(){
- System.out.println("Human is swinming");
- }
- }</span>
- <span style="font-size:18px">public class Man extends Human{
- @Override
- public void name() {
- System.out.println("I'm a men!!");
- }
- }
- </span>
- <span style="font-size:18px">public class Women extends Human{
- @Override
- public void name() {
- System.out.println("I'm a women");
- }
- }</span>
- <span style="font-size:18px">public class Text {
- public static void main(String[] arg0) {
- // Human h = new Human();
- // Man m = new Man();
- // m.name();
- Human a = new Man();
- Human b = new Women();
- Text.printYourName(a);
- Text.printYourName(b);
- }
- public static void printYourName(Human h) {
- h.name();
- }
- }</span>
结果如下;
I'm a men!!
I'm a women
访问修饰符:
private :只有本类可以访问,其他不管是继承还是在同一个包中都不能访问到该方法或者属性
protect:只有在继承角度上才有意义,继承可以访问到他,不管是不是在同一个中,其余意义类似于protect
public :等级最高,所有的类都能访问