标签:外部类 权限 返回 style -- 内存 回收 minor ffffff
今天主要回顾一下 Java 面向对象的最后一部分的知识,算是对面向对象的一个总结了吧!
先来讲两个关键字吧!
package abstractx; public class AbstractDemo { //不允许被实例化 //Pet p = new Pet(); //p.eat(); //创建的是匿名内部类 Pet p = new Pet(){ @Override public void eat() { // TODO Auto-generated method stub } }; } //不想让这个类实例化,就定义一个抽象类 abstract class Animal{} //抽象类 abstract class Pet{ // public Pet(){} //抽象方法,因为长得像方法,但是没有方法体 public abstract void eat();/*{ //System.out.println("在吃东西~~~");//有没有方法体都不重要了 }*/ public void drink(){ System.out.println("在喝水中~~~"); } } //子类继承抽象类之后必须重写其中的抽象方法,除非子类也是抽象类 class Cat extends Pet{ @Override public void eat(){ System.out.println("这只猫在吃土~~~"); } } class Dog extends Pet{ @Override public void eat(){ System.out.println("这只狗在吃猫~~~"); } }
package abstractx; public class AbstractExer { public static void main(String[] args) { Shape f; f = new Rectangle(3,4); System.out.println(f.getGirth() + "," + f.getArea()); f = new Oval(4,5); System.out.println(f.getGirth() + "," + f.getArea()); } } abstract class Shape{ public abstract double getGirth(); public abstract double getArea(); } //代表矩形 class Rectangle extends Shape{ double width; double height; public Rectangle(double width, double height){ this.width = width; this.height = height; } @Override public double getGirth() { return 2 * (width + height); } @Override public double getArea() { // TODO Auto-generated method stub return width * height; } } //正方形 class Square extends Rectangle{ private double width; public Square(double width) { super(width, width); } } //椭圆形 class Oval extends Shape{ private double a; private double b; public static final double PI = 3.14; public Oval(double a, double b){ this.a = a; this.b = b; } @Override public double getGirth() { // TODO Auto-generated method stub return PI * a * b; } @Override public double getArea() { // TODO Auto-generated method stub return PI * (a + b); } } //圆形 class Circle extends Oval{ private double r; public Circle(double r){ super(r, r); } }
package cn.tedu.interfacex; import java.io.Serializable; public class InterfaceDemo { public static void main(String[] args) { System.out.println(Shape.girth); //Shape.girth = 1;//说明是使用final修饰的 //接口不允许实例化 //Shape s = new Shape(); } } interface Shape extends Cloneable,Serializable{ double girth = 0;//默认是用的 static,final //public Shape(){}不允许使用 //接口中的方法默认public abstract修饰 /*public abstract */double getGirth(); public abstract double getArea(); } //利用implements关键字让类和接口产生了联系 --- 实现 //Rectangle实现了 Shape接口 /*class Rectangle implements Shape, Cloneable{ } */ interface E{ void main(); } /*class B implements E{ void main() {//报错了,范围不一样 } }*/
关于接口的实现中,我们有:
package cn.tedu.interfacex; public class InterfaceDemo2 { public static void main(String[] args) { A a = new B1(); //在 Java 中支持的是类和类之间的单继承 //所以此时会形成一颗结构树 //所以比较容易的就能确定两个类之间是否有继承关系 //因此在进行强制转换的时候 //会检查要转换的对象的声明类和转换的类型是否有继承关系 //a对象的声明类型是 A 类,要转换的类型是B1 //B1继承了A,所以在编译时期就不报错 //到了运行的时候才会检查对象的实际类型和要转换的类型是否一致 //运行的时候,发现a的实际类型是 B1,要转换的类型是B1 //类型一致,允许转换 B1 b1 = (B1) a;//编译、运行都不会报错 //a对象的声明类型是 A 类,要转换的类型是B2 //B2继承了A,所以在编译时期就不报错 //到了运行的时候,a的实际类型是B1,要转换的类型是B2 //类型不一致,所以报错 --- ClassCastException /*B2 b2 = (B2) a;//编译通过,但是运行会报错 B2 b3 = (B2) b1;//编译直接不通过 C c = (C) a;*///编译直接不通过 //在 Java 中,类和接口之间是多实现,接口和接口之间是继承关系 //所以构成了一张图状结构 --- 网状结构, //不容易确定两个节点之间的关系 //因此在编译时期为了提高效率放弃检查 //直到运行时候在确定类型是否是否相同 D d = (D) a;//编译通过,但是运行报错 } } class A{} class B1 extends A{} class B2 extends A{} class C{} interface D{}
package cn.tedu.innerclass; public class InnerDemo1 { public static void main(String[] args) { Outer1 outer1 = new Outer1(); outer1.m(); } } class Outer1{ int i = 10; public void m(){ System.out.println("Outer~~~"); //当方法内部类使用所在的方法中的数据的时候, //要求这个属性的是一个常量 //从JDK1.8开始,方法内部类使用到当前方法中的数据的时候,将该数据默认为常量,不能改变 //常量的隐式声明: int j = 5; //方法内部类 //只能在定义它的方法中使用 //可以使用外部类中的属性何方法 //如果内部类和外部类存在同名属性或者方法,则使用内部类中定义 //只能用abstract/final修饰 //方法内部类可以定义非静态的属性和非静态方法 //但是不能定义静态变量和静态方法 //然而定义静态常量 class Inner1{//不能用static 修饰 int k = 8; static final int x = 7;//会报错,加final变成一个常量 public void m(){ System.out.println("Inner~~~"); i += 5; m2(); //外部类.this.外部类的方法或者属性 Outer1.this.m2(); System.out.println(j); //j++;//会报错 } public void m2(){ System.out.println("Inner m2~~~"); } } Inner1 i1 = new Inner1(); i1.m(); } public void m2(){ System.out.println("m2~~~"); } }
package cn.tedu.innerclass; public class InnerDemo2 { public static void main(String[] args) { Outer2 o2 = new Outer2(); Outer2.Inner2 oi2 = new Outer2().new Inner2();//利用外部类对象创建内部类 System.out.println(oi2.j); } } class Outer2{ int i = 3; Inner2 i2 = new Inner2(); //成员内部类 //可以使用外部类中的属性和方法 //可以定义非静态属性和非静态方法 //但是不能定义静态属性和静态方法 //然而定义静态常量 class Inner2{//修饰不受什么限制 int j = 10; static final int k = 8;//也是要加final public void m(){ i += 3; Outer2.this.m();//调用外部类中的,不然就是递归了 } } public void m(){ System.out.println("Outer~~~"); } }
package cn.tedu.innerclass; public class InnerDemo3 { public static void main(String[] args) { Outer3.Inner3 oi3 = new Outer3.Inner3(); oi3.m(); } } class Outer3{ int i = 0; //静态内部类 //只能使用外部类中的静态属性和静态方法 //静态内部类中可以定义一切的方法和属性,无论静态还是非静态 static class Inner3{ int j = 8; static int k = 4; public void m(){ //System.out.println(i);//报错 } } }
package cn.tedu.innerclass; public class InnerDeom4 { public static void main(String[] args) { //匿名内部类 //a是匿名内部类产生的对象 //匿名内部类实际上是实现了对应的接口 A a = new A(){ @Override public void m() { System.out.println("running"); } }; a.m(); //匿名内部类实际上是继承了对应的类 B b = new B(){ @Override public void m() { System.out.println("running"); }}; b.m(); //C c = new C(){}; } } interface A{ void m(); } abstract class B{ public abstract void m(); } final class C{}
package cn.tedu.innerclass; public class LambdaDemo { public static void main(String[] args) { //接口中只定义了1个抽象方法 //可以利用 /*Calc c = new Calc(){ @Override public double add(double i, double j) { // TODO Auto-generated method stub return i + j; }};*/ //表示重写Calc中的唯一的一个抽象方法add //Lambda表达式只能作用在函数式接口上 //方法体只有一句,可以省略{}和return 不写 //唯一的依据方法体的计算结果默认为当前方法的返回值 //Calc c = (double i, double j) -> i + j; //重写的是 Calc 接口中的方法add //add方法的参数列表的类型是已知的 //可以省略参数类型不写 //函数式编程 Calc c = (x, y) -> x + y; System.out.println(c.add(4.3, 2.5)); } } interface Calc{ double add(double i, double j); }
接着,前面打一个小结,接下来进行包的介绍:
标签:外部类 权限 返回 style -- 内存 回收 minor ffffff
原文地址:https://www.cnblogs.com/tangdiao/p/9470431.html