大数据<javaSE + Linux精英实训班>_day_12
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(); } }
