欧博手机版下载:Java面向对象详解-下

admin/2020-07-11/ 分类:科技/阅读:

一、 static

  1. static:静态的,可以用来修饰属性、方式、代码块(或初始化块)、内部类
  2. static修饰属性(类变量):
    • 由类建立的所有的工具,都共用这一个属性
    • 当其中一个工具对此属性举行修改,会导致其他工具对此属性的一个挪用。vs 实例变量(非static修饰的属性,各个工具各自拥有一套副本)
    • 类变量随着类的加载而加载的,而且独一份
    • 静态的变量可以直接通过“类.类变量”的形式来挪用
    • 类变量的加载是要早于工具。以是当有工具以后,可以“工具.类变量”使用。然则"类.实例变量"是不行的。
    • 类变量存在于静态域中。
  3. static修饰方式(类方式):
    • 随着类的加载而加载,在内存中也是独一份
    • 可以直接通过“类.类方式”的方式挪用
    • 内部可以挪用静态的属性或静态的方式,而不能挪用非静态的属性或方式。反之,非静态的方式是可以挪用静态的属性或静态的方式
    • 静态的方式内是不能以有this或super关键字的!
    • 静态的结构(static的属性、方式、代码块、内部类)的生命周期要早于非静态的结构,同时被接纳也要晚于非静态的结构
  4. 开发中,若何确定一个属性是否要有声明为static的?
    • 属性可以被多个工具共享的,不会随着工具的差别而差别
  5. 开发中,若何确定一个方式是否要有声明为static的?
    • 操作静态属性的方式通常也是静态的
    • 工具类中对 方式通常也为static的
public class TestCircle { public static void main(String[] args) { Circle c1 = new Circle(); Circle c2 = new Circle(2.3); System.out.println(c1); System.out.println(c2); System.out.println(Circle.getTotal()); } } class Circle{ private double radius; private static String info = "我是一个圆"; private int id;//编号 private static int init = 1001;//控制每个工具的id private static int total = 0;//纪录建立了多少个工具 public Circle(){ this.id = init ; total ; } public Circle(double radius){ this.radius = radius; this.id = init ; total ; } public double getRadius() { return radius; } public void setRadius(double radius) { this.radius = radius; } public static String getInfo() { return info; } public static void setInfo(String info) { Circle.info = info; } public int getId() { return id; } public void setId(int id) { this.id = id; } public static int getTotal() { return total; } public static void setTotal(int total) { Circle.total = total; } @Override public String toString() { return "Circle [radius=" radius ", id=" id "]"; } public static void show(){ System.out.println(Circle.info); } public void desc(){ System.out.println(this.info); } } 

二、单例设计模式

解决的问题:若何只让设计的类只能建立一个工具
若何实现:饿汉式 & 懒汉式

1. 饿汉式1

class Bank{ //1.私有化组织器 private Bank(){} //2.建立类的工具,同时设置为private的,通过公共的来挪用,体现封装性 //4.要求此工具也为static的 private static Bank instance = new Bank(); //3.此公共的方式,必须为static public static Bank getInstance(){ return instance; } } 

2. 饿汉式2

class Bank{ //1.私有化组织器 private Bank(){} //2.建立类的工具,同时设置为private的,通过公共的来挪用,体现封装性 //4.要求此工具也为static的 private static Bank instance = null; static{ instance = new Bank(); } //3.此公共的方式,必须为static public static Bank getInstance(){ return instance; } } 

3. 懒汉式

class Bank{ private Bank(){} private static Bank instance = null; public static Bank getInstance(){ if(instance == null){//可能存在线程安全问题的! instance = new Bank(); } return instance; } } 

三、main()方式

public static void main(String[] args){ //方式体 } //1.main()是一个方式,是主方式,为程序的入口 //2.权限修饰符:public protected 缺省 private ---面向工具的封装性 //3.对于方式来讲:static final abstract //4.方式的返回值:void / 详细的返回值类型(基本的数据类型 & 引用数据类型),方式内部一定要有return //5.方式名:命名的规则:xxxYyyZzz。给方式命名时,要见名之意 //6.形参列表:统一个方式名差别的形参列表的诸多个方式间组成重载。 形参 & 实参---方式的参数通报机制:值通报 //7.方式体:方式界说的是一种功效,详细的实现由方式体操作。 

四、代码块

  1. 代码块:是类的第4个成员 { }
    作用:用来初始化类的属性
    分类:只能用static来修饰。
  2. 静态代码块:
    • 内里可以有输出语句
    • 随着类的加载而加载而且执行,而且只被加载一次
    • 多个静态代码块之间根据顺序结构执行
    • 静态代码块的执行要早于非静态代码块的执行。
    • 静态的代码块中只能执行静态的结构(类属性,类方式)
  3. 非静态代码块:
    • 可以对类的属性(静态的 & 非静态的)举行初始化操作,同时也可以挪用本类声明的方式(静态的 & 非静态的)
    • 内里可以有输出语句
    • 一个类中可以有多个非静态的代码块,多个代码块之间根据顺序结构执行
    • 每建立一个类的工具,非静态代码块就加载一次。
    • 非静态代码块的执行要早于组织器
  4. 关于属性赋值的操作:
    • 默认的初始化
    • 显式的初始化或代码块初始化(此处两个结构根据顺序执行)
    • 组织器中;
    • 以上是工具的属性初始化的历程------
    • 通过方式对工具的响应属性举行修改

1. 常见问题

总结:由父及子,静态先行

class Root{ static{ System.out.println("Root的静态初始化块"); } { System.out.println("Root的通俗初始化块"); } public Root(){ super(); System.out.println("Root的无参数的组织器"); } } class Mid extends Root{ static{ System.out.println("Mid的静态初始化块"); } { System.out.println("Mid的通俗初始化块"); } public Mid(){ super(); System.out.println("Mid的无参数的组织器"); } public Mid(String msg){ //通过this挪用统一类中重载的组织器 this(); System.out.println("Mid的带参数组织器,其参数值:" msg); } } class Leaf extends Mid{ static{ System.out.println("Leaf的静态初始化块"); } { System.out.println("Leaf的通俗初始化块"); } public Leaf(){ //通过super挪用父类中有一个字符串参数的组织器 super("尚硅谷"); System.out.println("Leaf的组织器"); } } public class LeafTest{ public static void main(String[] args){ new Leaf(); System.out.println(); new Leaf(); } } 
package com.atguigu.java3; class Father { static { System.out.println("11111111111"); } { System.out.println("22222222222"); } public Father() { System.out.println("33333333333"); } } public class Son extends Father { static { System.out.println("44444444444"); } { System.out.println("55555555555"); } public Son() { System.out.println("66666666666"); } public static void main(String[] args) { // 由父及子 静态先行 System.out.println("77777777777"); System.out.println("************************"); new Son(); System.out.println("************************"); new Son(); System.out.println("************************"); new Father(); } } 

五、final关键词

final:最终的 ,可以用来修饰类、属性、方式

  1. final修饰类:这个类就不能被继续。如:String类、StringBuffer类、System类
  2. final修饰方式:不能被重写。如:Object类的getClass()
  3. final修饰属性:此属性就是一个常量,一旦初始化后,不能再被赋值。习惯上,常量用大写字符示意
    此常量在那里赋值:①此常量不能使用默认初始化 ②可以显式的赋值、代码块、组织器。
  4. 变量用static final修饰:全局常量。好比:Math 类的PI
class D{ final int I = 12; final double PI; final String NAME; public void m1(){ System.out.println(I); // I = 10; } { PI = 3.14; } public D(){ NAME = "DD"; } public D(String name){ this(); //NAME = name; } } 

六、抽象 abstract

abstract:抽象的,用来修饰类、方式

  1. abstract修饰类:抽象类
    • 不能被实例化
    • 抽象类有组织器 (通常类都有组织器),便于子类实例化时挪用
    • 抽象方式所在的类,一定是抽象类
    • 抽象类中可以没有抽象方式。
    • 当我们设计一个类,不需要建立此类的实例时刻,就可以思量将其设置为抽象的,由其子类实现这个类的抽象方式以后,就行实例化
  2. abstract修饰方式:抽象方式
    • 花样:没有方式体,包罗{}.如:public abstract void eat();
    • 抽象方式只保留方式的功效,而详细的执行,交给继续抽象类的子类,由子类重写此抽象方式
    • 若子类继续抽象类,没有重写所有的抽象方式,意味着此类中仍有抽象方式,则此类必须声明为抽象的

1. 模板方式设计模式

//模板方式设计模式 public class TestTemplate { public static void main(String[] args) { new SubTemplate().spendTime(); } } abstract class Template { public abstract void code(); public void spendTime() { long start = System.currentTimeMillis(); this.code(); long end = System.currentTimeMillis(); System.out.println("破费的时间为:" (end - start)); } } class SubTemplate extends Template { public void code() { boolean flag = false; for(int i = 2;i <= 10000;i ){ for(int j = 2;j <= Math.sqrt(i);j ){ if(i % j == 0){ flag = true; break; } } if(!flag){ System.out.println(i); } flag = false; } } } 

2. 抽象类的应用

//抽象类的应用:模板方式的设计模式 public class TemplateMethodTest { public static void main(String[] args) { BankTemplateMethod btm = new DrawMoney(); btm.process(); BankTemplateMethod btm2 = new ManageMoney(); btm2.process(); } } abstract class BankTemplateMethod { // 详细方式 public void takeNumber() { System.out.println("取号排队"); } public abstract void transact(); // 解决详细的营业 //钩子方式 public void evaluate() { System.out.println("反馈评分"); } // 模板方式,把基本操作组合到一起,子类一样平常不能重写 public final void process() { this.takeNumber(); this.transact();// 像个钩子,详细执行时,挂哪个子类,就执行哪个子类的实现代码 this.evaluate(); } } class DrawMoney extends BankTemplateMethod { public void transact() { System.out.println("我要取款!!!"); } } class ManageMoney extends BankTemplateMethod { public void transact() { System.out.println("我要理财!我这里有2000万美元!!"); } } 

七、接口 interface

接口(interface) 是与类并行的一个观点

  1. 接口可以看做是一个特殊的抽象类是常量(public static final 可以省略)与抽象方式的一个聚集,不能包罗变量、一样平常的方式。
  2. 接口是没有组织器的
  3. 接口界说的就是一种功效。此功效可以被类所实现(implements)
    好比:class CC extends DD implements AA
  4. 实现接口的类,必须要重写其中的所有的抽象方式,方可实例化。若没有重写所有的抽象方式,则此类仍为一个抽象类
  5. 类可以实现多个接口。----java 中的类的继续是单继续的
  6. 接口与接口之间也是继续的关系,而且可以实现多继续

5,6形貌的是java中的继续的特点。

  1. 接口与详细的实现类之间也存在多态性

1. 接口的使用

  • 接口使用上也知足多态性
  • 接口,实际上就是界说了一种规范
  • 面向接口编程
public class USBTest { public static void main(String[] args) { Computer com = new Computer(); //1.建立了接口的非匿名实现类的非匿名工具 Flash flash = new Flash(); com.transferData(flash); //2. 建立了接口的非匿名实现类的匿名工具 com.transferData(new Printer()); //3. 建立了接口的匿名实现类的非匿名工具 USB phone = new USB(){ @Override public void start() { System.out.println("手机最先事情"); } @Override public void stop() { System.out.println("手机竣事事情"); } }; com.transferData(phone); //4. 建立了接口的匿名实现类的匿名工具 com.transferData(new USB(){ @Override public void start() { System.out.println("mp3最先事情"); } @Override public void stop() { System.out.println("mp3竣事事情"); } }); } } class Computer{ public void transferData(USB usb){//USB usb = new Flash(); usb.start(); System.out.println("详细传输数据的细节"); usb.stop(); } } interface USB{ //常量:界说了长、宽、最大最小的传输速率等 void start(); void stop(); } class Flash implements USB{ @Override public void start() { System.out.println("U盘开启事情"); } @Override public void stop() { System.out.println("U盘竣事事情"); } } class Printer implements USB{ @Override public void start() { System.out.println("打印机开启事情"); } @Override public void stop() { System.out.println("打印机竣事事情"); } } 

2. 工厂方式的设计模板

//接口的应用:工厂方式的设计模式 public class TestFactoryMethod { public static void main(String[] args) { IWorkFactory i = new StudentWorkFactory(); i.getWork().doWork(); IWorkFactory i1 = new TeacherWorkFactory(); i1.getWork().doWork(); } } interface IWorkFactory{ Work getWork(); } class StudentWorkFactory implements IWorkFactory{ @Override public Work getWork() { return new StudentWork(); } } class TeacherWorkFactory implements IWorkFactory{ @Override public Work getWork() { return new TeacherWork(); } } interface Work{ void doWork(); } class StudentWork implements Work{ @Override public void doWork() { System.out.println("学生写作业"); } } class TeacherWork implements Work{ @Override public void doWork() { System.out.println("先生批改作业"); } } 

3. 署理模式

//接口的应用:署理模式(静态署理) public class TestProxy { public static void main(String[] args) { Object obj = new ProxyObject(); obj.action(); } } interface Object{ void action(); } //署理类 class ProxyObject implements Object{ Object obj; public ProxyObject(){ System.out.println("署理类建立乐成"); obj = new ObjctImpl(); } public void action(){ System.out.println("署理类最先执行"); obj.action(); System.out.println("署理类执行竣事"); } } //被署理类 class ObjctImpl implements Object{ @Override public void action() { System.out.println("=====被署理类最先执行======"); System.out.println("=====详细的操作======"); System.out.println("=====被署理类执行完毕======"); } } 

4. 问题

interface A { int x = 0; } class B { int x = 1; } class C extends B implements A { public void pX() { //编译不通过。由于x是不明确的 // System.out.println(x); System.out.println(super.x);//1 System.out.println(A.x);//0 } public static void main(String[] args) { new C().pX(); } } 

5. Java8新特征

八、内部类

Java中允许将一类A声明在类B中,则类A就是内部类

1. 成员内部类(静态、非静态)

  • 作为一个类
    • 类内可以界说属性、方式、组织器
    • 可以被final修饰,示意此类不能继续,也就是不适用final,就可以被继续
    • 可以被abstract修饰
  • 作为外部类的
    • 挪用外部类的结构
    • 可以被static修饰
    • 可以被4种差别的权限修饰

局部内部类(方式内、代码块、组织器中)

public class InnerClassTest { public static void main(String[] args) { //建立Dog实例(静态的成员内部类): Person.Dog dog = new Person.Dog(); dog.show(); //建立Bird实例(非静态的成员内部类): // Person.Bird bird = new Person.Bird();//错误的 Person p = new Person(); Person.Bird bird = p.new Bird(); bird.sing(); System.out.println(); bird.display("黄鹂"); } } class Person{ String name = "小明"; int age; public void eat(){ System.out.println("人:用饭"); } //静态成员内部类 static class Dog{ String name; int age; public void show(){ System.out.println("卡拉是条狗"); // eat(); } } //非静态成员内部类 class Bird{ String name = "杜鹃"; public Bird(){ } public void sing(){ System.out.println("我是一只小小鸟"); Person.this.eat();//挪用外部类的非静态属性 eat(); System.out.println(age); } public void display(String name){ System.out.println(name);//方式的形参 System.out.println(this.name);//内部类的属性 System.out.println(Person.this.name);//外部类的属性 } } public void method(){ //局部内部类 class AA{ } } { //局部内部类 class BB{ } } public Person(){ //局部内部类 class CC{ } } } 

2. 注重

package com.atguigu.java; public class InnerClassTest { /* * 在局部内部类声明的方式中(好比:show)若是挪用局部内部类所声明的方式(好比:method)中的局部变量(好比:num)的话, * 要求此局部变量声明为final的。 * * jdk 7及之前版本:要求此局部变量显式的声明为final的 * jdk 8及之后的版本:可以省略final的声明 * */ public void method(){ //局部变量 int num = 10; class AA{ public void show(){ // num = 20; System.out.println(num); } } } } 
,

联博

www.326681.com采用以太坊区块链高度哈希值作为统计数据,联博以太坊统计数据开源、公平、无任何作弊可能性。联博统计免费提供API接口,支持多语言接入。

TAG:
阅读:
广告 330*360
广告 330*360
Sunbet_进入申博sunbet官网
微信二维码扫一扫
关注微信公众号
新闻自媒体 Copyright © 2002-2019 Sunbet 版权所有
二维码
意见反馈 二维码