P392饿汉和懒汉的区别
package com.yueeu;
public class Final {
public static void main(String[] args) {
//new C().Rate_get=0.99;
// (cannot assign a value to final variable Rate_get
}
}
final class A{//不能被继承（1）
}
class B{
public final void hi(){ }//如果要求不能被子类重写（2）//可以继承但不能重写
}
class D extends B{
// @Override
// public void hi() {
// System.out.println("重写了");
//}
}
class C{//不希望类的某个属性的值被修改，可以用final修饰
// public final double Rate_get=0.8;//(3)
}
class E{
public void cry(){
final double num=2.2;//当不希望某个局部变量被修改，可以用final修饰(3)
// num=3.3;
}
}P395final关键字细节
package com.yueeu;
public class Final {
public static void main(String[] args) {
}
}
class C{
public final double Rate_get=0.8;//1.定义时,而且必须给值
private final double Rate_get1;
private final double Rate_get2;
public static final double a=0.1;//静态属性只能在（1）和（2）静态代码块
public static final double a1;//因为静态属性在类加载的时候已经存在了
public C(){
Rate_get1=0.8;//2.构造器中
}
{
Rate_get2=0.7;//3.在代码块中
}
static {
a1=0.2;//(2)
}
}
（7）
package com.yueeu;
public class Final {
public static void main(String[] args) {
System.out.println(A.num); //输出1111
}
}
class A{
public final static int num=1111;//static，final前后无区别
static{
System.out.println("静态代码块被执行");
}
}
P397final练习
package com.yueeu;
public class Final {
public static void main(String[] args) {
System.out.println("面积="+new Circle(5.0).getarea());
}
}
class Circle{
private double radius;
private final double PI=3.14;//定义
private final double P1;
private final double P2;
public Circle(double radius){
this.radius=radius;
P1=3.1;//构造器
}
{
P2=3.2;//代码块
}
public double getarea(){
return PI*radius*radius;
}
}P398抽象类
public class Final {
public static void main(String[] args) {
}
}
abstract class Animal{
private String name;
public Animal(String name) {
this.name = name;
}//父类方法的不确定性，将把它设计为抽象方法
// public void eat(){//所谓抽象方法就是指没有实现的方法
//就是指没有方法体
// System.out.println("不知道该animal吃什么");
// }//当该类出现抽象方法，需要将该类声明为抽象类
//一般来说抽象类会被继承，由子类来继承该方法
public abstract void eat();
}
1
public class Final {
public static void main(String[] args) {
// new A()//抽象类不能被实例化
//抽象类可以没有抽象方法，但抽象方法必须属于抽象类
//abstract只能修饰方法和类；
}
}
abstract class A{
private String name;
public A(String name) {
this.name = name;
}
public abstract void eat();
}
abstract class A{
public abstract void eat();
}
abstract class C extends A{ }
//或者
class B extends A{
@Override
public void eat(){//相等于子类B实现父类A的抽象方法
//所谓实现方法就是有方法体
}
}
P401抽象类的练习
public class Final {
public static void main(String[] args) {
new Ma("mama",11,222,99).work();
}
}
class Ma extends Em{
private double bound;
public Ma(String name, int id, double salary, double bound) {
super(name, id, salary);
this.bound = bound;
}
@Override
public void work(){
System.out.println("经理"+getName()+"工作中");
}
}
abstract class Em{
private String name;
private int id;
private double salary;
public abstract void work();
public Em(String name, int id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public String getName() {
return name;
}
}
