1:面向对象->final关键字 继承的出现提高了代码的复用性,并方便我们开发。有些类在描述完之后不想被继承,有些 类的部分方法是固定的,不想让子类重写,那怎么解决? 用到关键字final->最终,不可变。final是一个修饰符,它可以用来修饰类,类的成员。 以及局部变量。
package om.itstra.demo01; /* * 在类的定义上,加上修饰符final * 类:最终类,不能有子类,不能被继承 * 这个类属于太监类,没有孩子 * */ public final class Fu { public void show() { System.out.println("最终类的方法"); } }
package om.itstra.demo01; //public class Zi extends Fu{ // 不可以 //}
package om.itstra.demo01; public class Test { public static void main(String[] args) { Fu f = new Fu(); f.show(); } }
final修饰方法:
package om.itstra.demo02; public class Fu { public final void show() { System.out.println("父类的最终方法"); } public void function() { System.out.println("父类的一般方法"); } }
package om.itstra.demo02; public class Zi extends Fu{ // public void show() { // 最终方法不能被重写 // } public void function() { System.out.println("子类的一般方法"); } }
package om.itstra.demo02; public class Test { public static void main(String[] args) { // 创建对象 Zi z = new Zi(); z.function(); z.show(); } }
final修饰的特点:
package om.itstra.demo03; public class Fu { public final void show() { System.out.println("父类当中的最终方法"); } public void function() { System.out.println("父类的普通方法"); } }
package om.itstra.demo03; public class Zi extends Fu{ public void function() { System.out.println("子类的一般方法"); } }
package om.itstra.demo03; public class Test { public static void main(String[] args) { Zi z = new Zi(); z.function(); z.show(); // 被final修饰一次赋值终身不变final修饰的可以看做常量 final int i = 3; // i = 8; // 不可以 i不可以被改值 //int j = i + 1; // 并没有修改i的值 System.out.println(i); // 保存的是内存地址 这块地址不变 final Zi z2 = new Zi(); //z2 = new Zi(); // 不可以 此时new地址就变量 } }
package om.itstra.demo04; /* * final修饰成员变量的测试 * final修饰的是成员变量,固定的不是内存的默认值 * 固定的是,成员变量的手动赋值,绝对不是内存的赋值 * * 成员变量的赋值,有两种实现方式: * 1、定义的时候直接 = 赋值 * 2、采用构造方法赋值 * 保证:被final修饰的成员变量只能赋值一次 */ public class Person { // final int age; // 这样定义不行 final int age = 5; // public Person(int age) { // this.age = age; // 不可以 // } }
static的使用:
2:面向对象->static
package om.itstra.demo05; /* * 定义Person类 * 定义对象的特有数据,和对象的共享数据 * 对象的特有数据(非静态修饰) 调用者只能new对象 * 对象的共享数据(静态修饰) 调用者可以new对象,也可以类名调用 * */ public class Person { String name; // 特有数据 static String className; // 共享数据 }
package om.itstra.demo05; public class Test { public static void main(String[] args) { Person p1 = new Person(); Person p2 = new Person(); p1.name = "喜喜羊"; p2.name = "美美羊"; System.out.println(p1.name); System.out.println(p2.name); p1.className = "基础班"; // 静态变量 可以直接用类名来进行调用 System.out.println(Person.className); } }
package om.itstra.demo06; /* * 静态的注意事项: * * 在静态中不能调用非静态 * * 为什么?生命周期 * 静态优先于非静态存在于内存当中 * * 静态:注意->静态不能写this,不能写super */ public class Student { private String name; private int age; // public static void function() { // System.out.println(age + name);// 不可以 在静态中不能调用非静态 // } private static String id; private static double price; // 非静态方法 可以用静态变量 原因:静态成员变量先进内存 可以直接拿来用,非静态属于对象 public void function() { System.out.println(id + price); } public static void main() { method(); } public static void method() { } }
static的应用场景:
package om.itstra.demo07; /* * 问题:static 静态到底什么时候用,应用场景 * * static 修饰成员变量 修饰成员方法 * 成员变量 static,根据具体的事物具体分析问题 * 定义事物的时候,多个事物之间是否有共性数据 * 请你将共性的数据定义为静态的成员变量 * * 成员方法加了static,跟着变量走 * 如果方法,没有调用过非静态成员,将方法定义为静态 * */ public class Student { private static String name; private static int age; // 是不是静态方法 取决于用的是不是静态变量 public static void function() { System.out.println(age + name); } private char sex; // 如果用了非静态变量的话 就不能加静态了 public void function1() { System.out.println(age + name+ sex); } // 以便可以直接通过类调用此方法 public static int getSum(int a,int b,int c) { return a + b + c; } }
static的注意事项:
package om.itstra.demo08; public class Fu { static int a = 1; public static void show() { System.out.println("父类的静态show方法"); } }
package om.itstra.demo08; public class Zi extends Fu{ static int a = 3; public static void show() { System.out.println("子类的静态show方法"); } }
package om.itstra.demo08; /* * 多态的调用过程。编译看谁?运行看谁? * 编译都是看 = 左边的父类,父类有编译成功,如果没有编译失败 * 运行,静态方法,运行父类当中的静态方法 * 运行,非静态方法,运行子类的重写方法 * * ! 成员变量,编译和运行全是父类 * */ public class Test { public static void main(String[] args) { // 创建多态对象 Fu f = new Zi(); // 1 System.out.println(f.a); // 结果父类的show方法 // 调用的是父类的静态方法,原因:静态属于类,不属于对象 // 对象多态性里面,静态和对象无关,父类的引用,静态方法 f.show(); } }
package om.itstra.demo09; /* * 在程序中,我们把固定不变的值设置为静态变量,之后记住变量名就可以了 * * 注意:接口中,每个成员变量默认使用的是public static final 修饰 * 接口当中的成员变量已经是静态变量了,由于接口当中没有构造方法,所以必须显示赋值,可以用接口名访问 * * 开发中,如果想在类中定义一个静态变量,通常使用public static final 修饰变量完成定义 * 此时,变量名要全部大写,多个单词用下划线连接 */ public class Static { public static final double PAI = 3.14; public static void main(String[] args) { System.out.println(PAI); } }
3:面向对象->匿名对象
指创建对象的时候,只有创建对象的语句,却没有把对象的地址值赋值给某个变量
package om.itstra.demo10; public class Person { public void eat() { System.out.println("人在吃饭"); } }
package om.itstra.demo10; import java.util.Scanner; /* * 匿名对象 * */ public class Test { public static void main(String[] args) { // 正常写法 Person p = new Person(); p.eat(); // 匿名写法 new Person().eat(); // 两个不同的人在吃 new Person().eat(); // 只能使用一次 // int i = new Scanner(System.in).nextInt(); // System.out.println(i); // 可以使用多次 Scanner sc = new Scanner(System.in); sc.nextInt(); sc.next(); // 匿名对象可以直接作为参数传递 method(new Person()); // 调用空参方法 Person p1 = new Person(); p1.eat(); // 匿名(只能使用一次) new Person().eat(); } // 方法返回的是Person类型 // return返回的是这个类的对象 public static Person method() { // Person p = new Person(); // return p; return new Person(); } public static void method(Person p) { p.eat(); } }