本文已参与「新人创作礼」活动，一起开启掘金创作之路。
Abstract学习
Abstract入门
package com.xz.abstract_;
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
//思考:这里eat这里你实现了，其实没有什么意义
//即: 父类方法不确定性的问题
//===>考虑将该方法设计为抽象(abstract)方法
//===> 所谓抽象方法就是没有实现的方法
//===> 所谓没有实现就是指，没有方法体
//===>当一个类中存在 抽象方法时，需要将该类声明为abstract类
//===>一般来说，抽象类会被继承，由其子类来实现抽象方法
// public void eat(){
// System.out.println("这是一只动物，但是不知道吃什么...");
// }
public abstract void eat();
}
package com.xz.abstract_;
public class AA extends Template{
public void job() {
long count = 0;
for (long i = 1; i <= 800000; i++) {
count += i;
}
}
}
package com.xz.abstract_;
public class BB extends Template {
public void job() {
long count = 0;
for (long i = 1; i <= 80000; i++) {
count *= i;
}
}
}
package com.xz.abstract_;
public abstract class Template {
public abstract void job();
public void calTime() {
//得到开始的时间
long start = System.currentTimeMillis();
job();//动态绑定机制
//得到结束的时间
long end = System.currentTimeMillis();
System.out.println("运行时间为：" + (end - start));
}
}
package com.xz.abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calTime();
BB bb = new BB();
bb.calTime();
}
}
package com.xz.abstract_;
public class AbstractDetail01 {
public static void main(String[] args) {
//抽象类不能被实例化
// A a = new A();
}
}
//1)抽象类不能被实例化
abstract class A {
}
//2)抽象类不一定要包含abstract方法。 也就是说抽象类可以没有abstract方法
abstract class B {
}
//3)一旦类包含 了abstract方法,则这个类必须声明为abstract
abstract class C {
public abstract void say();
}
//4) abstract只能修饰类和方法，不能修饰属性和其它的。
class D{
// public abstract int n1 = 10;
}
AbstractDetail
package com.xz.abstract_;
public class AbstractDetail01 {
public static void main(String[] args) {
//抽象类不能被实例化
// A a = new A();
}
}
//1)抽象类不能被实例化
abstract class A {
}
//2)抽象类不一定要包含abstract方法。 也就是说抽象类可以没有abstract方法
abstract class B {
}
//3)一旦类包含 了abstract方法,则这个类必须声明为abstract
abstract class C {
public abstract void say();
}
//4) abstract只能修饰类和方法，不能修饰属性和其它的。
class D{
// public abstract int n1 = 10;
}
AbstractExercise
package com.xz.abstract_;
public class AbstractExercise01 {
public static void main(String[] args) {
CommonEmployee commonEmployee = new CommonEmployee("jack", "jackie", 5000);
commonEmployee.work();
Manager manager = new Manager("xz", "zeaper", 10000, 5000);
manager.work();
}
}
abstract class Employee {
public String name;
public String id;
public double sal;
public Employee() {
}
public Employee(String name, String id, double sal) {
this.name = name;
this.id = id;
this.sal = sal;
}
public abstract void work();
}
class CommonEmployee extends Employee {
public CommonEmployee(String name, String id, double sal) {
super(name, id, sal);
}
@Override
public void work() {
System.out.println("普通员工" + name + "工作中...");
}
}
class Manager extends Employee {
public double bonus;
public Manager(String name, String id, double sal, double bonus) {
super(name, id, sal);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理" + name + "工作中...");
}
}
CodeBlock学习
CodeBlock入门
package com.xz.codeblock_;
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie1 = new Movie("你好,李焕英");
System.out.println("==============");
Movie movie2 = new Movie("唐探3",30);
System.out.println("==============");
Movie movie3 = new Movie("速激9",50,"林诣彬");
}
}
class Movie {
private String name;
private int price;
private String directer;
{
System.out.println("广告开始播放...");
System.out.println("电影开始播放...");
System.out.println("电影播放完毕...");
}
public Movie(String name) {
System.out.println("name");
this.name = name;
}
public Movie(String name, int price) {
System.out.println("name + price");
this.name = name;
this.price = price;
}
public Movie(String name, int price, String directer) {
System.out.println("name + price + directer");
this.name = name;
this.price = price;
this.directer = directer;
}
}
CodeBlockDetail01
package com.xz.codeblock_;
public class CodeBlockDetail {
public static void main(String[] args) {
//类 被加载的时候 静态代码块会被执行
//以下三种情况类会被加载
//1.创建对象实例时
//A a = new A();
//2.创建子类对象实例，父类代码块也会被加载
//A a1 = new A();
//3.使用类的静态成员时（静态属性、静态方法）
// System.out.println(Dog.n1);
//静态代码块只会被执行 (类只会加载一次)一次
// System.out.println(Dog.n1);
//普通代码块 被创建一次 就会就会调用一次
// DD dd1 = new DD();
// DD dd2 = new DD();
//如果只是使用类的静态成员，普通代码块并不会执行
System.out.println(DD.num);
}
}
class DD {
public static int num = 999;
static {
System.out.println("DD的静态代码块被执行...");
System.out.println("=================");
}
//在new对象时会被调用，每加载一次就会被执行一次
//可以这样简单理解：普通代码块是构造器的一种补充机制，构造器没被调用，普通代码块也不会被调用
{
System.out.println("DD的普通代码块被执行...");
}
}
class Dog {
public static int n1 = 10;
static {
System.out.println("Dog的代码块被执行...");
System.out.println("=================");
}
}
class A extends B {
static {
System.out.println("A的代码块被执行...");
System.out.println("=================");
}
}
class B {
static {
System.out.println("B的代码块被执行...");
System.out.println("=================");
}
}
CodeBlockDetail02
package com.xz.codeblock_;
public class CodeBlockDetail02 {
public static void main(String[] args) {
AA aa = new AA();
}
}
//静态代码块优先级高于普通代码块
//最后执行的才是构造方法
class AA {
//无参构造器
public AA() {
System.out.println("无参构造器被调用...");
}
//普通属性的初始化
private int n2 = getN2();
{
System.out.println("普通代码块被执行...");
}
private int getN2() {
System.out.println("getN2被调用...");
return 200;
}
//属性初始化和静态代码块执行优先级一样
//所以系统会按顺序执行
//属性初始化
private static int n1 = getN1();
//静态代码块
static {
System.out.println("静态代码块被执行....");
}
public static int getN1() {
System.out.println("getN1被调用...");
return 100;
}
}
Final关键字学习
fianl关键字入门
package com.xz.final_;
public class Final01 {
public static void main(String[] args) {
E e = new E();
// e.TAX_RATE=0.09;
}
}
//1.不希望被继承，可加final
final class A {
}
//class B extends A{
//}
//2.不希望父类某个方法被子类覆盖/重写
class C {
public final void say() {
System.out.println("say()...");
}
}
//class D extends C {
// @Override
// public void say() {
// super.say();
// }
//}
//3.不希望某个属性的值被修改
class E {
public final double TAX_RATE = 0.08;
}
//4.不希望某个局部变量被修改
class F {
public void hi() {
final double TAX_RATE = 0.08;
// TAX_rate = 0.09;
System.out.println(TAX_RATE);
}
}
FinalDetail01
package com.xz.final_;
public class FinalDetail {
public static void main(String[] args) {
CC cc = new CC();
EE ee = new EE();
ee.say();
}
}
class AA {
/*
* final修饰的常量可赋值的地方
* 1. 定义时
* 2. 构造器
* 3. 代码块
*/
public final double TAX_RATE1 = 0.08;
public final double TAX_RATE2;
public final double TAX_RATE3;
public AA(double TAX_RATE2) {
this.TAX_RATE2 = 12.5;
}
{
TAX_RATE3 = 8.8;
}
}
class BB {
/*
* 如果final定义的属性是静态的，则初始化的位置只能是
* 1. 定义时
* 2. 静态代码块
* 不能在构造器中赋值
*/
public static final double TAX_RATE1 = 0.08;
public static final double TAX_RATE2;
static {
TAX_RATE2 = 8.8;
}
}
//final类不能继承，但是可以实例化对象
class CC {
}
//如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
//即 仍然遵守继承的机制
class DD {
public final void say() {
System.out.println("say()...");
}
}
class EE extends DD {
}
FinalDetail02
package com.xz.final_;
public class FinalDetail02 {
public static void main(String[] args) {
//代码块不会被执行
System.out.println(CCC.rate);
}
}
//5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
final class AAA {
// public final void say(){
// System.out.println("say()...");
// }
}
//6) final不能修饰构造方法(即构造器)
class BBB {
public String name;
// public final BBB(String name) {
// this.name = name;
// }
}
//7) final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class CCC {
public final static double rate = 0.08;
static {
System.out.println("代码块...");
}
}
//8)包装类(Integer,Double,Float, Boolean等都是final),String也是final类,不可以被继承。
//class DDD extends String{}
