Java object-oriented explanation – next
•
Java
1、 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);
}
}
2、 Singleton design pattern
The problem to be solved: how to make the designed class create only one object, and how to implement: hungry man type & lazy man type
1. Hungry Han style 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. Hungry Han style 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. Lazy style
class Bank{
private Bank(){}
private static Bank instance = null;
public static Bank getInstance(){
if(instance == null){//可能存在线程安全问题的！
instance = new Bank();
}
return instance;
}
}
3、 Main() method
public static void main(String[] args){
//方法体
}
//1.main()是一个方法，是主方法，为程序的入口
//2.权限修饰符：public protected 缺省 private ---面向对象的封装性
//3.对于方法来讲：static final abstract
//4.方法的返回值：void / 具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return
//5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意
//6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。 形参 & 实参---方法的参数传递机制：值传递
//7.方法体：方法定义的是一种功能，具体的实现由方法体操作。
4、 Code block
1. Frequently asked questions
Summary: by parent and child, static first
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();
}
}
5、 Final keyword
Final: final, which can be used to modify classes, attributes and methods
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;
}
}
6、 Abstract
Abstract: abstract, used to modify classes and methods
1. Template method design mode
//模板方法设计模式
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. Application of abstract classes
//抽象类的应用：模板方法的设计模式
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万美元!!");
}
}
7、 Interface interface
Interface is a concept parallel to class
1. Use of interface
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. Design template of factory method
//接口的应用：工厂方法的设计模式
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. Agency mode
//接口的应用：代理模式（静态代理）
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. Problems
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. New features of Java 8
8、 Inner class
Java allows a Class A to be declared in class B, then class A is an inner class
1. Member internal class (static and non static)
Local internal classes (within methods, code blocks, constructors)
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. Attention
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);
}
}
}
}
The content of this article comes from the network collection of netizens. It is used as a learning reference. The copyright belongs to the original author.
THE END
二维码