【Java4】实例初始化，类初始化，/接口，多态，final/static，权限修饰符/native
2024-06-05 17:39:57
文章目录
- 1.实例初始化过程：有几个构造器，就会有几个实例初始化方法
- 2.实例初始化和类初始化结合：先类（静态）后实
- 3.接口：只有abstract可省
- 3.1 鸟类案例：Flyable相当于父类的一个补丁，因为有的鸟会飞，有的鸟不会飞
- 3.2 继承（extends）和实现（implements）：extends B,C错
- 4.多态：和属性无关，只说方法
- 4.1 多态弊端：用instanceof 避免
- 4.2 多态应用：USB相当于animal抽象类改为接口，里面connect是抽象方法
- 5.final：final只有get方法
- 6.static：修饰的成变不进堆
- 7.四大权限修饰符：记住中间两个本包，ppdp
- 8.native：调用C/C++
1.实例初始化过程：有几个构造器，就会有几个实例初始化方法
package com.atguigu.test01.block;
/** 1、类的成员：* （1）属性：成员变量* （2）方法：成员方法* （3）构造器* （4）代码块分为如下：非静态代码块， 静态代码块(后面讲，和static一起说)* * 2、非静态代码块* （1）声明的格式：* 【修饰符】 class 类名{* {* 非静态代码块;* }* }* （2）非静态代码块中的代码什么时候执行？ 在“每次”创建对象的时候执行，比构造器早执行。* （3）实例初始化过程：创建对象时，为对象进行初始化的操作，如下【1】和【2】按代码先后，反正【3】最后。* 【1】为成员变量显式赋值 【2】执行非静态代码块 【3】执行构造器* * Java编译器会把这三个部分的代码，合成一个叫做<init>(【形参列表】)（在.class中）实例初始化方法* 即编译后的.class字节码信息中，是没有构造器这个概念。 */
public class TestBlock {public static void main(String[] args) { Demo d1 = new Demo();//调用无参构造，本质上是调用<init>()实例初始化方法Demo d2 = new Demo("atguigu");//调用有参构造，本质上是调用<init>(形参列表)实例初始化方法}
}class Demo{{System.out.println("非静态代码块1");} private String str = assign();//调用方法，来为str进行显式赋值public Demo(){System.out.println("无参构造");}public Demo(String str){this.str = str;System.out.println("有参构造");}{System.out.println("非静态代码块2");}public String assign(){System.out.println("assign方法");return "hello";}
}
如下的线上面是d1实例初始化过程，都是构造排最后。
package com.atguigu.test01.block;public class TestInit {public static void main(String[] args) {/*Son s = new Son();父类的无参构造（运行结果）子类的无参构造*/ /*Son s2 = new Son("atguigu");父类的无参构造子类的有参构造1*/ Son s3 = new Son("atguigu", 10);/*父类的无参构造子类的有参构造1子类的有参构造2*/}
}
class Father{public Father(){System.out.println("父类的无参构造");}
}
class Son extends Father{private String str;private int num; public Son(){//隐含了super(); 子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造System.out.println("子类的无参构造");} public Son(String str){//隐含了super()this.str = str;System.out.println("子类的有参构造1");}public Son(String str,int num){this(str); //间接调用父类无参构造this.num = num;System.out.println("子类的有参构造2");}
}
package com.atguigu.test01.block;
/** super()或super(实参列表)之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法* super()或super(实例列表）之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行*/
public class TestInit2 {public static void main(String[] args) {Zi z = new Zi();//312645 //先是super()}
}
class Fu{private String strFu = assignFu();{System.out.println("(1)父类的非静态代码块");}public Fu(){System.out.println("(2)父类的无参构造");}public String assignFu(){System.out.println("(3)父类的assignFu()");return "fu";}
}//1111111111111111111111111111111111111111111111111111111111111111111111111111
class Zi extends Fu{private String strZi = assignZi();{System.out.println("(4)子类的非静态代码块");}public Zi(){//super() ==>调用父类的实例初始化方法，而且它在子类实例初始化方法的首行。//有extends先调用构造器System.out.println("(5)子类的无参构造");} public String assignZi(){System.out.println("(6)子类的assignZi()");return "zi";}
}
package com.atguigu.test01.block;public class TestInit3 {public static void main(String[] args) {Er r = new Er();//612645，因为子类重写了assign()，所以3忽略
// Ba b = new Ba(); //312}
}
class Ba{private String str = assign();{System.out.println("(1)父类的非静态代码块");}public Ba(){System.out.println("(2)父类的无参构造");}public String assign(){System.out.println("(3)父类的assign()");return "ba";}
}
class Er extends Ba{private String str = assign();{System.out.println("(4)子类的非静态代码块");}public Er(){//super() ==>调用父类的实例初始化方法，而且它在子类实例初始化方法的首行，有extends先调用构造器System.out.println("(5)子类的无参构造");} public String assign(){System.out.println("(6)子类的assign()");return "er";}
}
package com.atguigu.homewok.test06;
/** 实例初始化的过程：* （1）父类的实例初始化* <init>(){* x = 10;//父类的x* this.print();//子类的print，因为this代表的是正在创建的子类对象，而子类重写了print，所以是子类的print。System.out.println("Son.x = " + x);//子类的x 没有赋值x=0x = 20;//父类的x* }* * （2）子类的实例初始化* <init>(){* x = 30;//子类的x* this.print();//子类的print。System.out.println("Son.x = " + x);//子类的x 已经赋值x=30x = 40;//子类的x* }*/
public class Test06 {public static void main(String[] args) {Father f = new Son(); //先父类构造再子类构造System.out.println(f.x);//编译时是Father类型，访问Father中的x x=20（属性看编译时即左类型）}
}class Father{int x = 10;public Father(){this.print();x = 20;}public void print(){System.out.println("Father.x = " + x);}
}class Son extends Father{int x = 30;public Son(){this.print();x = 40;}public void print(){System.out.println("Son.x = " + x);}
}
package com.atguigu.homewok.test07;
/**（1）Test07类的初始化* <clinit>(){* int x = 5;//局部变量x--;//局部变量 x=4* Test07.x--;//静态变量 x = -1* }**（2）执行main方法* System.out.println("x=" + x);//静态变量 -1* z--;//静态变量 z=-1* method();* y = z++ + ++z;//静态变量 ，加载为准 *《1》先加载z的值“-1” //《2》z自增，z=0 《3》z自增 z =1《4》加载z的值“1” 《5》求和 “-1” + “1” = 0 《6》把0赋值给y y=0* System.out.println("result:" + (z + y + ++z));*《1》加载z的值“1” 《2》加载y的值"0" 《3》z自增 z=2 《4》加载z的值“2” 《5》求和 “1” + “0” + “2”*/
public class Test07 {static int x, y, z;//类变量，静态变量，成员变量 默认值0static {int x = 5;//局部变量x--;//局部变量}static {x--;//静态变量}public static void main(String[] args) {System.out.println("x=" + x);//静态变量z--;//静态变量method();System.out.println("result:" + (z + y + ++z));//静态变量}public static void method() {y = z++ + ++z;//静态变量}
}
package com.atguigu.homewok.test08;
/** 1、Base b1 = new Base();* 父类的实例初始化，和子类无关* <init>(){* method(100);* System.out.println("base : " + i); base:100* }* * 2、Base b2 = new Sub();*（1） 父类的实例初始化* <init>(){* method(100);//执行了子类重写的method() //重要！！！* System.out.println("sub : " + j); sub:100* }*（2）子类的实例初始化* <init>(){* super.method(70);* System.out.println("base : " + i); base:70* }*/
public class Test08 {public static void main(String[] args) {Base b1 = new Base();Base b2 = new Sub();}
}class Base {Base() {method(100);}public void method(int i) {System.out.println("base : " + i);}
}class Sub extends Base {Sub() {super.method(70);}public void method(int j) {System.out.println("sub : " + j);}
}
package com.atguigu.homewok.test09;
// 考了两个内容：final，方法的参数传递机制
public class Test09 {public static void main(String[] args) {Other o = new Other(); //o.i=0new Test09().addOne(o); //i=1System.out.println(o.i); //1} //o是引用数据类型，实参给形参的是地址值，那么形参修改了属性，实参也会修改//o变量的值不能修改，不是说i的值不能修改public void addOne(final Other o){o.i++;}
}
class Other{public int i;//默认值0
}
package com.atguigu.homewok.test02.day10;
/** 实例初始化的过程：* (1)父类的实例初始化* <init>(){* System.out.print("1");* }* * (2)子类的实例初始化 * <init>(String name){* System.out.print("3");* father = new People(name + " F");//创建了一个父类的对象* 调用父类的<init>(String name){* System.out.print("2");* }* }*/
public class Test02 {public static void main(String[] args) {new Child("mike");}
}class People {private String name;public People() {System.out.print("1");}public People(String name) {System.out.print("2");this.name = name;}
}class Child extends People {People father;public Child(String name) {//隐含了super()，走了父类的无参构造System.out.print("3");father = new People(name + " F");}public Child() {System.out.print("4");}
}
package com.atguigu.homewok.test07.day10;
/** new A(new B());* （1）new B()* <init>(){* System.out.println("B");* }* *（2）new A(B的对象即B b)* <init>(B b){* this();* System.out.println("A");* System.out.println("AB");* }*/
public class Test07 {public static void main(String[] args) {new A(new B());}
}class A {public A() {System.out.println("A");}public A(B b) {this();System.out.println("AB");}
}class B {public B() {System.out.println("B");}
}
package com.atguigu.homewok.test08.day10;
/** （1）父类实例初始化* <init>(){* System.out.println("base");* method(100); //子类重写了，执行子类的method //System.out.println("sub : " + j); sub:100* }* * （2）子类实例初始化* <init>(){* System.out.println("sub"); sub* super.method(70); //父类的method //System.out.println("base : " + i); base 70* }*/
public class Test08 {public static void main(String[] args) {Sub s = new Sub();}
}class Base{Base(){method(100);}{System.out.println("base");}public void method(int i){System.out.println("base : " + i);}
}class Sub extends Base{Sub(){//隐含了：super()super.method(70); //注意super.}{System.out.println("sub");}public void method(int j){System.out.println("sub : " + j);}
}
2.实例初始化和类初始化结合：先类（静态）后实
package com.atguigu.test04;public class TestInit {public static void main(String[] args) {Demo d = new Demo();//2631745}
}
class Demo{{System.out.println("（1）Demo的非静态代码块1");}static{System.out.println("（2）Demo的静态代码块1");}private static String info = assign();private String message = getMessage();static{System.out.println("（3）Demo的静态代码块2");}{System.out.println("（4）Demo的非静态代码块2");}public Demo(){System.out.println("（5）无参构造");}public static String assign(){System.out.println("（6）assign()方法");return "hello";}public String getMessage(){System.out.println("（7）getMessage()方法");return "msg";}
}
package com.atguigu.test04;
/** (1)先完成父类的类初始化* (2)再完成子类的类初始化* (3)父类的实例初始化方法* (4)子类的实例初始化方法*/
public class TestInit2 {public static void main(String[] args) {DemoZi zi1 = new DemoZi(); //2，6，3/，9，13，10/，1，14，4，5/，8，14，11，12System.out.println("-------------------");DemoZi zi2 = new DemoZi();}
}
class DemoFu{{System.out.println("（1）Demo的非静态代码块1");}static{System.out.println("（2）Demo的静态代码块1");}private static String info = assign();private String message = getMessage(); //子类重写了static{System.out.println("（3）Demo的静态代码块2");}{System.out.println("（4）Demo的非静态代码块2");}public DemoFu(){System.out.println("（5）无参构造");}public static String assign(){System.out.println("（6）assign()方法");return "hello";}public String getMessage(){System.out.println("（7）getMessage()方法");return "msg";}
}
class DemoZi extends DemoFu{{System.out.println("（8）");}static{System.out.println("（9）");}private static String info = assign();private String message = getMessage();static{System.out.println("（10）");}{System.out.println("（11）");}public DemoZi(){System.out.println("（12）");}public static String assign(){System.out.println("（13）");return "hello";}public String getMessage(){System.out.println("（14）getMessage()方法");return "msg";}
}
3.接口：只有abstract可省
抽（abstract可省）/默（default不可省）。静（static不可省，方片，类名/接口名.）/常。
类中只有final修饰要初始化，其他不需要。
package com.itheima04.constant;
/*
* 接口中的常量：1. 接口中的属性没有变量都是常量(一次赋值,终身不变)。默认用 public static final 修饰
* 2. static (静态) : 可以接口名直接调用
* 3. final (最终): 用final修饰的属性是常量,一次赋值,终身不变
* 4. 软性规范: 常量名一般大写
*/
public class ConstantDemo {public static void main(String[] args) {System.out.println(A.I); //1System.out.println(Student.K); //2 //类名.调用因为static，不能修改因为final(钉子钉住了)System.out.println(Student.j); //0 //Student.i报错,不是静态不能类名.调用}
}
class Student{ //以下都不报错int i; static int j;public final static int K = 2;
}
interface A{int I = 1;public static final int J = 2;
}
3.1 鸟类案例：Flyable相当于父类的一个补丁，因为有的鸟会飞，有的鸟不会飞
package com.itheima05.bird;public class BirdDemo {public static void main(String[] args) {Sparrow sparrow = new Sparrow();sparrow.name = "杰克";sparrow.eat(); //杰克正在吃东西sparrow.fly(); //杰克正在扑腾Qq qq = new Qq();qq.name = "企鹅";qq.eat(); //企鹅正在吃东西}
}
class Bird{String name;int age;//alt+insert快捷键构造函数，但必须鼠标停在类中public Bird(){}public Bird(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name + "正在吃东西");}
}//11111111111111111111111111111111111111111111111111111111111111111111111
interface Flyable{void fly(); //抽象方法
}
class Sparrow extends Bird implements Flyable{ //子类默认调用父类的空参构造@Overridepublic void fly() {System.out.println(name + "正在扑腾");}
}
class Qq extends Bird{}
如下和上面无关。
public class TestInterfaceDefineAndUse {public static void main(String[] args) {// Flyable f = new Flyable();//接口不能直接创建对象的Flyable[] sky = new Flyable[3]; //存放接口的数组//数组的元素类型Flyable类型，是接口类型sky[0] = new Bird();//多态引用sky[1] = new Plane();sky[2] = new Kite(); for (int i = 0; i < sky.length; i++) {//数组的元素类型Flyable类型，是接口类型sky[i].fly();}}
}
interface Flyable{// public static final long MAX_SPEED = 7900000;long MAX_SPEED = 7900000;
// public abstract void fly();void fly();
}
interface Jumpable{void jump();
}
class Animal{
}//1111111111111111111111111111111111111111111111111111111111111111111
class Bird extends Animal implements Flyable,Jumpable {//重写接口的抽象方法，实现接口的抽象方法@Overridepublic void fly() {System.out.println("小鸟振翅高飞");}@Overridepublic void jump() {System.out.println("双脚跳");}
}class Plane implements Flyable{@Overridepublic void fly() {System.out.println("靠发动机带动飞行");}
}
class Kite implements Flyable{@Overridepublic void fly() {System.out.println("靠人放");}
}//1111111111111111111111111111111111111111111111111111111111111111
interface A{void a();
}
interface B{void b();
}
interface C extends A,B{void c();
}
class Impl implements C{ //必须重写3个方法@Overridepublic void a() {}@Overridepublic void b() {}@Overridepublic void c() {}
}
因为接口必须重写抽象方法，吃草吃肉和J无关。
package com.itheima06.tedian;
/*
* 1. 如果两个父接口存在相同 抽象方法。 解决: 子类随便重写一个即可
* 2. 如果两个父接口存在相同 默认方法。 解决: 子类必须重写这个默认方法
* 3. 如果两个父接口存在相同 静态方法, 常量。 子类什么都不用做,直接用 接口名调用
*/
public class Demo02 {public static void main(String[] args) {J j = new J();j.method(); // 10 20}
}
interface H{public static final int NUMBER = 10; //常量void eat(); //抽象default void eat2(){ //默认//吃草}static void eat3(){ //静态}
}
interface I{public static final int NUMBER = 20; void eat(); default void eat2(){ }static void eat3(){ }
}//111111111111111111111111111111111111111111111111111111111111111111
class J implements H,I{ //H,I 是 J的父接口@Overridepublic void eat() {}@Overridepublic void eat2() {//不能带上default//到底吃什么,子类重写后说了算} void method(){System.out.println(H.NUMBER); //如下都是static，用接口.调用System.out.println(I.NUMBER);H.eat3();I.eat3();}
}
3.2 继承（extends）和实现（implements）：extends B,C错
package com.itheima06.tedian;
/*
* 1. 类继承类: 只能单继承,不能多继承 class A extends B { }
* 2. 类实现接口: 可以多实现，没有接口与类之间关系 class A implements B,C...{ }
* 3. 接口继承接口: 可以多继承 interface A extends B,C...{ }
*/
public class Demo03 {public static void main(String[] args) {}
}
interface M{void eat();
}
interface L{void run();
}
interface N extends M,L{}class O implements N{ //1@Override public void eat() {}@Overridepublic void run() {}
}class P implements M,L{ //2同1@Overridepublic void eat() {}@Overridepublic void run() {}
}
package com.itheima06.tedian;
/** 1. 一个类S 继承类Q, 又实现接口R (而Q和R又有相同的方法)* 符合就近原则: 继承类Q中的方法 * 2. (而Q和R又有相同的方法 : Q中方法不抽象 R方法抽象)* 那么子类不用重写R中抽象方法。原理: 用Q中继承过来的方法来 代替 抽象方法重写*/
public class Demo04 {public static void main(String[] args) { S s = new S();s.eat(); //吃草}
}
abstract class Q{public void eat(){System.out.println("吃草");}public abstract void eat2();public void eat3(){ //不抽象，S类中不用重写}
}
interface R{default void eat(){System.out.println("吃肉");}void eat2();void eat3();
}
class S extends Q implements R{@Overridepublic void eat2() { //必须重写抽象方法}
}
/*1. 任何一个类(除Object之外), 如果没有显示声明继承哪个,那么直接继承Object2. 用类中继承来的同名方法 代替 接口中的抽象方法重写
*/
interface T{boolean equals(Object obj);
}
class U implements T{ //class U extends Object implements T //Object有equals方法
}
4.多态：和属性无关，只说方法
package com.itheima07.duotai;
/*
* java精髓: 接口和多态。多态：提高代码扩展性(当需求改变的时候,代码改的越少,扩展性越强)
* 1. 含义: 一种行为却展示出多种形态
* 2. 表述: 父类/父接口 引用 指向子类对象。 父类/父接口 引用调用方法,执行的是子类重写的方法
* 3. 多态三要素，必要条件
* 1. 继承 (类继承,接口)
* 2. 重写 (方法重写)
* 3. 向上转型 (父类引用指向子类对象)
*
* 向上转型(默认成立的)
* 1. 前提 : 基于继承关系
* 2. 格式：父类类型 变量/引用 = new 子类类型();
* 3. 含义：子类对象 实际上 都可以说是 父类中一种实例即看到狗就说它是种动物
*
* 为什么一定需要方法重写? 编译看左边,运行看右边
* 1. 运行的时候,子类对象会运行子类重写的方法,无论左边类型是父类/子类(Animal/Dog)
* 2. 问题: 父类中定义的方法 没有用,那为什么一定要写？ 是为了通过编译
* 1. 编译看左边
* java代码 -> .class文件 -> runtime
* 编译 运行
* (编译器 : 不知道运行阶段的事 即 右边的事不关心)
* 2. 运行看右边：右边的内容是在运行阶段赋值给左边
*/
public class DuotaiDemo {public static void main(String[] args) {// Dog dog = new Dog(); //这是方法重写不是多态
// dog.eat();//向上转型 : 前提继承。如下a是内存地址/变量/引用 即 父类引用指向子类对象Animal a = new Dog(); //多态的表现出来的特征：1.编译类型与运行时类型不一致，2.方法重写a.eat();// 一种行为eat,多种形态(什么形态.具体要取决是什么对象)。//打印出：狗在吃骨头}
}//11111111111111111111111111111111111111111111111111111111111111111
abstract class Animal{public void eat(){System.out.println("动物在吃饭");}
}
class Dog extends Animal{public void eat() {System.out.println("狗在吃骨头");}
}
class Cat extends Animal{public void eat() {System.out.println("猫在吃鱼");}
}
如下通过编译了，运行报错（右边true运行时才赋值给左边）。
4.1 多态弊端：用instanceof 避免
如下是多态的好处。
如下不看注释掉的，只需给method(new Dog())传入实参，更简便。
如上会出现问题：猫, 狗,狼 吃各自的东西。但如果是猫, 猫还会加餐吃 猫粮即add方法（如钻石会员加个特效）。
如下是强制向下转型弊端：method(new Dog())。
package com.itheima09.duotai3;
/*
* 多态的弊端：向上转型（默认一定成功，向下转型可能失败）之后, 父类引用无法调用子类 特有 的方法(编译看左边)
* 解决：向下转型 也叫 强制类型转换：子类类型 变量 = (子类类型)父类引用
*
* 强制类型转换是有可能失败的 : ClassCastException(类转换异常)。失败条件: 对象实际上是A类型,硬要转换成B类型
* 避免: 添加一个类型判断：（boolean result = 变量 instanceof 类型）如果变量刚好是A类型, 返回true
*/
public class DuotaiDemo {public static void main(String[] args) {// 需求: 让各种动物吃东西(早上让猫吃,晚上让狼吃)，多态Animal a = new Cat(); //没用methoda.eat(); //猫在吃鱼Wolf w = new Wolf();method(w); //狼吃肉method(new Cat()); //猫在吃鱼 猫加餐吃猫粮method(new Dog()); //狗在吃骨头}//1111111111111111111111111111111111111111111111111111111111111111111111 public static void method(Animal a){a.eat(); boolean result = a instanceof Cat;if(result){Cat c = (Cat)a; //向下转型c.add();}}
}
abstract class Animal{public abstract void eat();
}
class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗在吃骨头");}
}
class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫在吃鱼");}public void add(){System.out.println("猫加餐吃猫粮");}
}
class Wolf extends Animal{@Overridepublic void eat() {System.out.println("狼吃肉");}
}
4.2 多态应用：USB相当于animal抽象类改为接口，里面connect是抽象方法
如下extend()相当于上面method()，USB usb相当于Animal a，usb.connect()相当于a.eat()。
package com.itheima10.computer;public class Computer { //主void open(){System.out.println("电脑开机了");}void close(){System.out.println("电脑关机了");}void extend(USB usb){//interface USB不能实例化，可以USB usb但不能调用时用new USB()传入，new 子类传入usb.connect();}
}//11111111111111111111111111111111111111111111111111111111111111111111111
interface USB{ //补丁 //接口: 标准/规范 void connect(); //下定义 : 抽象方法
}
class Mouse implements USB{ // 实现接口: 符合某种标准@Overridepublic void connect() {System.out.println("鼠标连接上了");}
}
class Keyboard implements USB{@Overridepublic void connect() {System.out.println("键盘连接上了");}
}
package com.itheima10.computer;
import com.itheima10.computer.Computer;public class TestDemo {public static void main(String[] args) {Computer computer = new Computer();computer.open();computer.close();//如下不能写成Computer m =new Mouse();因为不存在继承关系，不是多态Mouse m = new Mouse();computer.extend(m); Keyboard k = new Keyboard();computer.extend(k); // k：USB usb = new Keyboard(); //usb可以实例化，因为Keyboard这个类实现了USB这个接口 }
}
package com.atguigu.test02.polymorphism;
/** 多态的应用：多态数组：数组的元素是父类的类型，实际存储的是子类的对象，用这样的数组就可以统一管理所有子类的对象。*/
public class TestUse1 {public static void main(String[] args) {//创建一个数组，可以存储各种图形的对象，包括圆对象，矩形对象，三角形对象...//Circle[] yuans = new Circle[3]; //这个数组存圆 //本态数组//Rectangle[] jus = new Rectangle[3]; //这个数组存矩形 Graphic[] all = new Graphic[3];//这个数组就可以存储各种图形的对象all[0] = new Circle(1.2); //左边的元素all[0]是Graphic类型，右边是子类圆对象Graphic g2 = new Rectangle(2, 4); //多态//左边g2是Graphic，右边是矩形对象,如下分开写和上面一样。all[1] = g2;all[2] = new Circle(4.2);//遍历所有图形的面积for (int i = 0; i < all.length; i++) {//执行哪个getArea()方法，要看all[i]中存储的是哪个子类的对象System.out.println("面积：" + all[i].getArea());}}
}//1111111111111111111111111111111111111111111111111111111111111111111111111111
class Graphic{ //Graphic图形public double getArea(){return 0.0;//这句话没有什么意义，只是为了保证语法}
}
class Circle extends Graphic{private double radius;public Circle(double radius) {this.radius = radius;} public double getArea(){ //重写return 3.14 * radius * radius;}
}
class Rectangle extends Graphic{private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;} public double getArea(){ //重写return length * width;}
}
接口是规范/标准，多态是拓展性。
5.final：final只有get方法
package com.itheima00.question;
public class Demo01 {public static void main(String[] args) {// 继承关系分为如下两种:FuClass fc = new Zi(); //类继承 FuIn fi = new Zi(); //接口实现 // 如上向上转型，如下向下转型 // 父类类型变量 instanceof 子类类型：用来判断是不是继承的// boolean result = fc instanceof String; //错误，因为fc和String没有继承关系 boolean result = fi instanceof Zi;//可以true，fc instanceof Zi也为true}
}
interface FuIn{}
class FuClass{}
class Zi extends FuClass implements FuIn{}
package com.itheima01.finald;
/*
* final：不可继承(类)如String类很完美 不可重写(方法) 不可修改(属性)
* 方法重写的出现打破了类的封装性, final修饰方法既保证了封装,又保证了继承
*/
public class Demo01 {public static void main(String[] args) {C c = new C();c.eat(); //不能重写但能继承 //联合声明: ~~}
}
class B {public final void eat(){ //final 修饰方法可继承，不是类。System.out.println("联合声明: ~~");}
}
class C extends B{ //C是B的发言人
}
如下i有默认初始值0，所以若final int j = 0，final写了没意义，主因D类使用时无法给j赋值。
解决如上问题还有如下构造器方法，但是需要删除有漏洞的有参构造器。
如下无漏洞的有参构造器。
/*
* 问题: 解释一下都用final修饰,成员变量不给初始值会编译报错, 而局部变量不给初始值不会报错
* 1. 终级规则: java中的变量在使用时,必须有值！！！
* 2. final修饰的成员变量没有默认值
* 3. 现象归纳:
* 1. final修饰变量 如果可以 直接赋值
* 2. final修饰成员变量 , 可以在构造方法中赋值 (如果有多个构造,必须都要赋值,也只会执行其中一个)
* 3. final修饰局部变量, 只要保证使用前有值即可，不用不会报错
*/
6.static：修饰的成变不进堆
package com.itheima02.staticd;
/*
* static 修饰：1.属性，2.方法，3.代码块
* static修饰属性
* 1. 可以用类名/接口名 直接访问 !!!
* 问题: 为什么非静态属性必须对象调用? 而静态属性可以类名调用?
* 因为static是属于类的, 随着类的加载而加载, 优先于对象
* 1. 非静态属性在堆里中,属于对象的 (有几个对象,就有几份)
* 2. 静态属性在方法区(类区)中, 属于类的 (在内存只有一份，共享一值)
*
* 2. 静态属性 也可以 通过对象名来调用(不推荐) : 每个对象实际上都是类的实例
* 3. 静态属性 被该类所有对象所共享 (只有一个对象进行修改,那么其他对象的该静态属性都会随之修改)
* 运用: 非静态属性各自对象私有, 静态属性大家共有
*/
public class StaticDemo01 {public static void main(String[] args) {/* A a = new A();System.out.println(a.i); // 可以，a为对象System.out.println(A.j);*/ //可以，A为类名A a1 = new A();a1.i = 2;A a2 = new A();System.out.println(a2.i);// 1，不是2System.out.println(A.j); //以下这几个都一样都为2System.out.println(a1.j);System.out.println(a2.j);System.out.println("--------------------");a1.j = 10;System.out.println(a2.j); //10，j静态，改了都改a2.j = 20;System.out.println(a1.j); //20System.out.println(A.j); //20System.out.println("--------------------");Student s1 = new Student();Student s2 = new Student();s1.schoolName = "黑马";System.out.println(s2.schoolName); //黑马Student.schoolName = "白马";System.out.println(s1.schoolName); //白马}
}
class A{int i = 1; //非静态属性static int j = 2; //静态属性，不给值也没事，因为static可以使用默认初始值，不是final
}
class Student{String name;int age;int money;static String schoolName;
}
package com.itheima02.staticd;
/*
* static修饰方法：0. static随着类的加载而加载, static内容属于类不会进堆。static修饰的内容加载时会进方法区（静态区/类区），非static修饰的内容加载时会进方法区（非静态区/对象区）。
*
* 1. static方法 可以通过类名调用
* 问题: 为什么 非静态方法地址 要记录到 堆内存?
* 原因: 非静态方法 可以访问 非静态属性 , 不同的对象的非静态属性是不一样的
* 不同的对象 非静态方法 执行效果也有所不同，所以涉及对象，进堆
*
* 2. static属于类的,跟对象无关 (static优先于对象加载 : 先来调用后到的)
* 2.1 static方法不能调用非静态的属性和方法(跟对象有关系都不可以)
* 2.2 this 和super关键字都不行
* 只要该类对象, 调用静态方法执行效果都一样!!!
*/
public class StaticDemo02 {public static void main(String[] args) { B b1 = new B(); b1.name = "张三";B b2 = new B(); //又new了，地址不同b2.name = "李四";b1.method01(); //张三:method01 com.itheima.demo02.B@4554617cb2.method01(); //李四:method01 com.itheima.demo02.B@74a14482b1.method02(); //static method02b2.method02(); //static method02B.method02(); //static method02B b = null; //null指堆是空的，找不到method01()//b.method01(); //NullPointerException 空指针异常 空引用b.method02(); //static method02，对象是空的也没事，静态方法不进堆}
}
class B{String name;public void method01(){System.out.println(name + ":method01");System.out.println(this); //com.itheima.demo02.B@4554617c//System.out.println(this.name); }public static void method02(){//public和static位置无所谓，只要在返回值前就可以System.out.println( "static method02");}
}
如下method02静态，this属于对象，所以报错。加上name+"static…"会报错，因为name非静态，定义改为static String name就可以。
package com.itheima02.staticd;
/*
* static 修饰属性和方法
* 1. static 属性
* 1. 访问 : 类名.静态属性 (标准)
* 对象名.静态属性(可以,不推荐)
* 2. 静态属性在内存独一份,该类所有对象共享,其中一个对象,其他对象该属性都会改变
* 3. 运用: 类的公共属性设置静态(比如: 一个学校的学生: schoolName)
*
* 2. static 方法
* 1. 访问 : 类名.静态方法 (标准)* 对象名.静态方法(可以,不推荐)* 2. 静态方法 不可以调用 非静态的内容 (类先加载,再创建对象)* 静态属于类的,随着类的加载而加载的。补充: 非静态可以调用静态* 非静态内容: 属性,方法, this,super...* 3. 运用: 只要这个方法跟对象中其他内容无关,都可设计static* 好处: 节省内存,调用方便*/
public class StaticDemo03 { //这类名和main方法无关，只是借用类名调用下main方法，所以main是静态的
// static int i;public static void main(String[] args) { //右击运行时jvm会调用main这个入口方法int add = C.add(1, 2); //这行不创建对象，好处节省内存，不用在堆上创建空间System.out.println(add); //3// System.out.println(i); //上面第一行static int i注释放开可以 //0method03();C c = new C();c.method01(); // 1 2 2 //非静态对象名.调用}private static void method03() { // 默认static,因为main是static}
}
class C{int field = 1;static int sField = 2; public void method01(){System.out.println(field);System.out.println(sField);method02();}public static void method02(){// System.out.println(field); //非静态报错
// method01(); //非静态报错System.out.println(sField);}public static int add(int a, int b){ //这个方法独立于这个对象之外，设计为静态return a + b;}
}
package com.itheima02.staticd;
/*
* 需求场景: 安装软件/驱动 只要做一次
* 静态代码块
* static{
* // 代码
* }
* 1. 随着类的加载而执行, 优先于构造, 只执行一次
* 2. 只要类加载就能运行,无需手动调用
* 3. 运用: 数据库 (注册驱动)
*/
public class StaticDemo04 {/** 右单击: javac xx.java -> java xx（ideal帮做）* 运行: JVM底层 StaticDemo04.main(args) 【main是静态方法，类名.调用】* 1. 类先加载 : static代码块先运行，比main方法更快* 2. 轮到static方法*/static{System.out.println("xx");}public static void main(String[] args) {D d1 = new D();D d2 = new D();D d3 = new D();System.out.println("yy");}
}
class D{static{System.out.println("随着类的加载而执行,无需手动调用");System.out.println("因为类的加载全局只有一次,所以static代码块全局只执行一次");System.out.println("类的加载优先于对象创建,static代码块最先执行的");}public D(){System.out.println("D的构造方法");}//方法需要手动调用static void method(){System.out.println("静态方法");}
}
如下没有创建对象，没有调用方法，运行依然显示：静态代码块。
如下因为info是static，所以assign方法也应为static。
如下不确定=非静态。
7.四大权限修饰符：记住中间两个本包，ppdp
package com.itheima03.privilege;
import com.itheima00.question.Fu;
/*
* java四大权限修饰符：public > protected > default(不写) > private
* 1. public : 公共的 , 全工程可访问
* 2. protected : 受保护的 , 【本包 + 跨包子类内部】
* 3. default : 默认, 【本包】
* 4. private: 私有, 除【本类】内部,其他不可访问
*/
public class FourDemo {public static void main(String[] args) {Fu fu = new Fu();Zi zi = new Zi();}
}
class Zi extends Fu{ public void eat(){System.out.println(id1);System.out.println(id2); //跨包 子类的内部可访问 //import com.itheima00.question.Fu;}
}
package com.itheima04.review;
/*
* 修饰符：static，final，abstract，default
* 修饰符矛盾 (编译报错):
* 1. private 和 abstract 不能共存: abstract方法不重写没有意义,但是private方法又不能被重写 -> 矛盾
* 2. final 和 abstract 不能共存: final修饰的方法不能被重写
* 3. static 和 abstract 不能共存: static方法也不能被重写，因为static方法属于类
*/
public class XiuShiFuDemo {public static void main(String[] args) {}
}
abstract class A{abstract void method01(); //没有{}方法体,前面没有public，只有接口默认有publicprivate static void method02(){ //可以，只能在本类里让其他方法调用如下}static void method03(){ method02();}
}
package com.itheima04.review;
//这部分代码面板效果如下图
public class Demo02 {public static void main(String[] args) {}
}
interface MyInterface{int I = 1; //public static final //final修饰可以用构造赋值，但interface没构造，写完就赋初始值void method(); // public abstract
}
abstract class MyClass{public int id1;protected int id2;int id3;private int id4; public MyClass(){}public static int id5;public final int id6 = 1;public static final int id7 = 1;public String method(int a, int b){return "";}public abstract void method2();
}
class F extends MyClass{@Overridepublic void method2() {}
}
抽象方法：半粉色。f：黄色属性
8.native：调用C/C++
package com.atguigu.test02;
/** native：也是一个修饰符* 1、意思：原生的、本地的* 2、可以修饰什么？可以修饰方法* 3、它修饰的方法有什么不同？* 语法格式：* 【修饰符】 class 类{* 【其他修饰符】 native 返回值类型 方法名(【形参列表】);* }* native修饰的方法，看不见方法体。* native修饰的方法，不是用Java语言实现的，而是调用了底层C/C++的代码，这些代码* 被编译为.dll文件(windows下.dll，linux下是.lib文件)，让Java来执行。 * * （1）native方法，对于Java程序员来说，该怎么调用还怎么调用* （2）子类还可以选择对它进行重写*/
public class TestNative {public static void main(String[] args) {Object obj = new Object();System.out.println(obj.hashCode());// 151.....MyClass ob = new MyClass(); //不能为obj和上面同名System.out.println(ob.hashCode());// 1}
}
class MyClass extends Object{//重写父类的native方法@Overridepublic int hashCode() {return 1;}
}
D:\development\jdk1.8\jre\bin 文件夹里有很多.dll文件。
【Java4】实例初始化，类初始化，/接口，多态，final/static，权限修饰符/native相关推荐
- java内部类的权限符,static介绍、内部类、final、权限修饰符的作用范围，
static介绍.内部类.final.权限修饰符的作用范围,static 关键字:(可用于修饰方法.变量) static 特点: static是静态修饰符,一般修饰成员变量.被static修饰的属于全 ...
- 绝密101：import,java,packag的顺序、权限修饰符、类及其组成可用的修饰符
import,java,packag他们三个直接有没有顺序呢? packag:到达的路径,所在文件的路径,他最终以包的形式结束(他在最前面) import:导入外界你想要使用的类,它最终以你想要结束的 ...
- 包 权限修饰符 final 常量 枚举 抽象类 接口 多态 内部类 常用API 正则表达式 Lambda
包 什么是包? 包是用来分门别类的管理各种不同类的,类似于文件夹.建包利于程序的管理和维护. 建包的语法格式:package 公司域名倒写.技术名称.报名建议全部英文小写,且具备意义. package ...
- java基础2：this、static、final、abstract关键字、代码块、生成API工具包、继承、多态、方法重载和重写，抽象类、接口、常见异常、java权限修饰符、选择排序思想和程序和内部类
1.this关键字 this表示当前类对象的地址空间值的引用.就是说,this代表了new出来的对象 其最大作用就是解决了构造器中局部变量隐藏成员变量.即用this.变量名 = 变量名 区分. 2.s ...
- 第三周 Java语法总结__static关键字__代码块__继承__this和super的区别__重写__final关键字__多态__抽象__接口__形参问题__包__权限修饰符__内部类
文章目录 6.static关键字 1)静态static关键字的特点: 2)关于static关键字的使用注意事项 3)什么时候将变量定义为成员变量: 7.文档说明书: 8.代码块 9.继承 1)继承的概 ...
- 笔记整理3----Java语言高级（三）11 综合练习+12 面向对象-static变量 与 代码块+13 面向对象-继承与抽象类+14 面向对象-接口与多态+15 面向对象-包修饰符
11 综合练习+12 面向对象-static变量 与 代码块+13 面向对象-继承与抽象类+14 面向对象-接口与多态+15 面向对象-包&修饰符 第11天 综合练习 今日内容介绍 综合练习 ...
- day12、面向对象进阶（包、权限修饰符、final、常量、枚举、抽象类、接口）
面向对象进阶(包.权限修饰符.final.常量.枚举.抽象类.接口) 包 权限修饰符 final 常量 常量概述和基本作用 常量做信息标志和分类 枚举 枚举的概述 枚举的使用场景演示 抽象类 抽象类概 ...
- 权限修饰符| 重写 和 重载之间的区别| super和this的区别|Object类|equals 和 ==的区别|多态|转型 cast的总结
权限修饰符 本类 同包类 不同包子类 不同包下的其他类 private T default(默认) T T protected T T T public T T T T 注意: 以上权限修饰符只能修饰 ...
- 05【继承、抽象、权限修饰符、final】
文章目录 05[继承.抽象.权限修饰符.final] 一.继承 1.1 继承概述 1.2 继承的格式 1.3 继承案例 1.3.1 需求 1.3.2 分析 1.3.3 代码实现 1.4 父类不可被继承 ...
最新文章
- R语言ggplot2可视化分面图（faceting）、设置每个分面的标题在右侧（right side）、并在右侧分面图的外侧添加整图的标题信息（facet title）
- 使用未编译的XAML动态生成WPF控件
- win 7 系统激活工具
- Uri跟Url的区别
- python操作excel和txt文件
- 剑指Offer面试题：4.从尾到头打印链表
- P1351-联合权值【树形结构】
- div自定义下拉框组件
- 有史以来最强的 5G 入门科普！
- 使用Docker部署SpringBoot
- 跨进程的 键盘钩子_Delphi下深入Windows编程之钩子原理一
- oracle 表 队列,如何将复制队列表移出系统(SYSTEM)表空间
- （6）数据分析-方差分析
- linux服务器console口,Linux重定向console口控制台
- 智能时代，谁是“大师”？
- intel32/ctor.dll mysql_ctor.dll,下载,简介,描述,修复,等相关问题一站搞定_DLL之家
- 程序员持续记录开始赚钱之旅 (第二十一篇)
- yum https ssl双向认证 证书申请
- vue : 无法加载文件 C:\Users\Lenovo\AppData\Roaming\npm\vue.ps1。...无法在当前系统上运行该脚本。
- 大华NVR设备接分别入宇视摄像机Onvif和RTSP主子码流的方案说明