java_面向对象编程

最新推荐文章于 2023-03-17 18:36:09 发布
最新推荐文章于 2023-03-17 18:36:09 发布
阅读量906 收藏 1
点赞数
分类专栏： JAVA开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34229228/article/details/109321262
版权

文章目录

一、类

package com.atguigu.contact;

public class MyPacakage {
	public static void main(String[] args) {
		//声明类
		Turtle turtle=new Turtle();
		turtle.color="绿色";
		System.out.println(turtle.color);
		turtle.climb("大黄");	
	}
}

//创建一个类
class Turtle{
	//类的属性
	String color;
	int legs=4;
	//类的方法
	void climb(String name){
		System.out.println("我是乌龟"+name);
	}
}

二、内存解析

在这里插入图片描述
在这里插入图片描述

三、成员变量+局部变量

在这里插入图片描述

三、方法的声明

在这里插入图片描述
在这里插入图片描述

package com.atguigu.contact;

import java.util.Arrays;

public class MyPacakage {
	public static void main(String[] args) {
		Student[] s = new Student[20];
		for (int i = 0; i < 20; i++) {

			s[i] = new Student();
			s[i].number = i + 1;
			s[i].state = (int) (Math.random() * 5 + 1);
			s[i].score = (int) (Math.random() * 101 + 1);
		}
		MyPacakage test = new MyPacakage();
		// 打印state為3
		test.display_3(s);
		//冒泡排序
		test.bubble(s);
		// 遍历
		test.allThrough(s);
	}
	
	
	public void allThrough(Student[] s) {
		for (int i = 0; i < s.length; i++) {
				s[i].display(s[i]);
		}
	}
	
	
	public void display_3(Student[] s) {
		for (int i = 0; i < s.length; i++) {
			if (s[i].score == 3) {
				s[i].display(s[i]);
			}
		}
	}
	
	
	public void bubble(Student[] s) {
		// 冒泡排序來遍歷成績
		for (int j = 0; j < s.length - 1; j++) {
			for (int i = 1; i < s.length - j; i++) {
				if (s[i - 1].score > s[i].score) {
					Student temp = s[i];
					s[i] = s[i - 1];
					s[i - 1] = temp;
				}}}}
}

class Student {
	int number;
	int state;
	int score;

	public void display(Student s) {
		System.out.println("學號：" + s.number + "年級：" + s.state + "成績：" + s.score);
	}

}

匿名对象

在这里插入图片描述

方法的重载

类中具有两个或两个以上的相同方法名，但形参列表不同就构成了方法重载。
在这里插入图片描述
在这里插入图片描述

可变形参

数据类型…变量名
在这里插入图片描述

方法参数的值传递机制

  • 如果是基本数据类型，参数传递时传递的是变量的值

  • 引用数据类型，参数传递时传递的是地址值

  • 方法调用时，实际传递给形参的数据，叫实参

  • 方法定义时，方法小括号里的参数，叫做形参

  • 如果是基本数据类型，实参传递给形参时，只是单纯的变量值传递。

  • 如果是引用数据类型，实参传递给形参时，传递的是地址值。

参数类型为基本数据类型

调用方法交换m,n会发现main函数中的m,n位置并没交换，究其本质，看它的内存传递机制。
在这里插入图片描述

== 参数类型为引用数据类型==
调用方法交换m,n会发现main函数中的m,n位置也交换了，究其本质，看它的内存传递机制。
在这里插入图片描述
在这里插入图片描述

递归

package Array_ex;

public class diGui {
	public static void main(String[] args) {
		diGui test = new diGui();
		System.out.println(test.f(10));
	}
	
	//递归，f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n);其中n是＞0，求f(10)
	public int f(int n) {
		if(n==0) {
			return 1;
		}else if(n==1) {
			return 4;
		}else {
			return 2*f(n-1)+f(n-2);
		}
	}
	
}

四、封装

在这里插入图片描述

在这里插入图片描述

package com.atguigu.contact;

public class MyPacakage {
	public static void main(String[] args) {
		Turtle turtle=new Turtle();
		turtle.setLegs(4);
		System.out.println(turtle.getLegs());
	}
}

//创建一个类
class Turtle{
	//将属性设置为私有属性
	private int legs;
	
	
	//设置私有属性的值
	public void setLegs(int nums) {
		if(0<nums && nums%2==0) {
			legs=nums;
		}else {
			legs=0;
		}
		
	}
	
	//获取私有属性
		public int getLegs() {
			return legs;
		}
	
	void climb(String name){
		System.out.println("我是乌龟"+name);
	}
}

Java的四种权限修饰符

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

五、类的构造器（Constructor）

  • 作用：1）用来创建对象 new+构造器；2）初始化对象的属性信息。
  • 若没有显示定义的构造器，系统默认提供一个空参的构造器。
  • 若显示定义了类的构造器，则系统不再提供默认的空参构造器
  • 一个类中至少有一个构造器
  • 定义构造器的格式：修饰符 类名（形参列表）｛｝
    在这里插入图片描述

== 构造器很像python里的__init__，用于对象的属性初始化赋值操作 ==

package com.atguigu.concat;

public class MyObject {
	public static void main(String[] args) {
		Person p=new Person(18,"Tom");
		System.out.println(p.age+p.name);
	}

}

class Person{
	int age;
	String name;
	
	public Person(int n,String m) {
		age=n;
		name=m;
	}	
}

补充：属性赋值操作的先后顺序

在这里插入图片描述

补充：JavaBean

在这里插入图片描述

补充：UML类图

在这里插入图片描述

this关键字

类比python的self.
在这里插入图片描述

练习：银行收存款余额

package Array_ex;

public class Account {
	private double balance;

	public Account(double balance) {
		this.balance = balance;
	}

	public double getBalance() {
		return balance;
	}

	// 存款
	public void deposit(double amt) {
		if (amt > 0) {
			balance += amt;
			System.out.println("存钱成功");
		}
	}

	// 取款
	public void withdraw(double amt) {
		if (balance >= amt) {
			balance -= amt;
			System.out.println("取钱成功");
			return;
		}
		System.out.println("余额不足，取款失败");

	}

}



package Array_ex;

public class Customer {
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String firstName, String lastName) {
		super();
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public Account getAccount() {
		return account;
	}

	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}

}



package Array_ex;

public class Bank {
	private Customer[] customers;//存放多個客戶的數組
	private int numberOfCustomer;//記録客戶的個數
	
	public Bank() {
		customers = new Customer[10];

	}
	
	public void addCustomer(String f, String l) {
		Customer c = new Customer(f, l);
		customers[numberOfCustomer++]=c;
		
	}



	public int getNumberOfCustomer() {
		return numberOfCustomer;
	}
	
	
	public Customer getCustomers(int index) {
		
		return customers[index];
	}
}

package Array_ex;

public class BankTest {
	public static void main(String[] args) {
		Bank b = new Bank();
		b.addCustomer("Jane","Smith");
		b.getCustomers(0).setAccount(new Account(110.0));
		b.getCustomers(0).getAccount().deposit(10.0);
		b.getCustomers(0).getAccount().withdraw(10.0);
	}
	

}

pacakge关键字

在这里插入图片描述
在这里插入图片描述

MVC设计模式

在这里插入图片描述

在这里插入图片描述

import关键字


在这里插入图片描述

六、继承（extends）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

package com.atguigu.contact;

// 父类
public class Person {
	int legs = 2;
	int eyes = 2;
	
	public Person() {
		
	}
	
	public void eat() {
		System.out.println("吃飯");
	}
}

//子类
package com.atguigu.contact;

public class Student extends Person {
	int age = 18;
	public Student() {
		
	}
	
	public void study() {
		System.out.println("學習");
	}
}

//主函数
package com.atguigu.contact;

public class MyTest {
	public static void main(String[] args) {
		Person p = new Person();
		Student s = new Student();
		p.eat();
		s.eat();
		s.study();
	}
}

方法的重写

注意：重写方法非static，非private

在这里插入图片描述
在这里插入图片描述

方法的重载和重写

在这里插入图片描述

super关键字

在这里插入图片描述

在这里插入图片描述

//父类
package myex;

public class Account {
	private int id;
	private double balance;
	private double annualInterestRate;
	
	public Account() {
		
	}
	
	public Account(int id, double balance, double annualInterestRate) {
		super();
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}
	public double getBalance() {
		return balance;
	}
	public double getAnnualInterestRate() {
		return annualInterestRate;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
	
	public double getMonthlyInterest() {
		return getAnnualInterestRate()/12;
	}
	
	public void withdraw(double amount) {
		if (amount>balance) {
			System.out.println("余额不足，取款失败");
		}else {
			balance-=amount;
//			System.out.println("取款成功，余额为："+balance);
		}
	}
	public void deposit(double amount) {
		balance+=amount;
//		System.out.println("存款成功，余额为："+balance);
	}
}

//子类，练习super关键字
package myex;

public class CheckAccount extends Account {
	double overdraft;
	
	public CheckAccount(int id, double balance, double annualInterestRate, double overdraft) {
		super(id, balance, annualInterestRate);
		this.overdraft = overdraft;
		
	}

	public void withdraw(double amount) {
		if (amount<getBalance()) {
			System.out.println("可以直接取款");
			//setBalance(getBalance()-amount);
			super.withdraw(amount);
		}else {
				double needOverdraft = amount-getBalance();
				if(needOverdraft>overdraft) {
					System.out.println("用户超过可透支额的限额");
				}else {
					overdraft-=needOverdraft;
					setBalance(0.0);
					
			}
		}
	}
	}

//测试用例
package myex;

public class AccountTest {
	public static void main(String[] args) {

		CheckAccount c = new CheckAccount(1122,20000,0.0045,5000);
		c.withdraw(5000);
		System.out.println("余额为："+c.getBalance());
		System.out.println("允许透支余额为："+c.overdraft);
		c.withdraw(18000);
		System.out.println("余额为："+c.getBalance());
		System.out.println("允许透支余额为："+c.overdraft);
		c.withdraw(3000);
		System.out.println("余额为："+c.getBalance());
		System.out.println("允许透支余额为："+c.overdraft);
		
	}

}

子类对象实例化的全过程

在这里插入图片描述

七、多态

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.atguigu.concat;
//父类
public class Person1 {
	int age;
	String neme;
	
	public void eat() {
		System.out.println("人吃饭");
	}
}

//子类
public class Man extends Person1 {
	public void eat() {
		System.out.println("男的吃饭多");
	}
}

//测试用例
public class myex {
	public static void main(String[] args) {
		Person1 p = new Person1();//多态性
		Person1 p2 = new Man();
		p2.eat();
		
	}

}

在这里插入图片描述

在这里插入图片描述

类的向下转型

向下转型：将父类强转成子类
在这里插入图片描述
在这里插入图片描述

package com.atguigu.concat;

public class myex {
	public static void main(String[] args) {
		Person1 p2 = new Man();
		Man m = (Man)p2;//强制类型转换
		m.isSmoking=false;
		p2.eat();	
	}
}

instanceof关键字

在这里插入图片描述
在这里插入图片描述

八、Object类

在这里插入图片描述

equals()

Object类中判断两个对象的地址是否相同，但我们使用时的目的往往是判断对象的内容是否相同，因此要对对象进行重写。

==和equals()有什么区别？

在这里插入图片描述
在这里插入图片描述

重写equals方法

在这里插入图片描述

package com.atguigu.contact;

public class Person {
	String name;
	int age;
	int id=1;
	
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	
	@Override
	//重写原则，比较两个对象实体内容是否相同
	public boolean equals(Object obj) {
			if(this == obj) {
				return true;
			}
			if (obj instanceof Person) {
				Person objTest = (Person)obj;
				//比较对象的每个属性是否都相同
				return this.age == objTest.age && this.name.equals(objTest.name);
			}
			return false;
	}
	
}

//测试用例
package com.atguigu.contact;

public class MyTest {
	public static void main(String[] args) {
		Person p1 = new Person("张三", 18);
		Person p2 = new Person("张三", 18);
		System.out.println(p1.equals(p2));
	}
}

toString()

在这里插入图片描述

@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", id=" + id + "]";
	}
  • getClass()、hashCode()、clone()、 finalize()、wait()、notify()、notifyAll()
    在这里插入图片描述

Junit单元测试

在这里插入图片描述

import org.junit.jupiter.api.Test;

public class JunitTest {
	int num = 10;
	@Test
	public void testEquals() {
		String s1="MM";
		String s2="MM";
		System.out.println(s1.equals(s2));
		System.out.println(num);
	}
}

包装类

在这里插入图片描述

基本类、包装类和String类的转换

在这里插入图片描述

package com.atguigu.contact;

import org.junit.jupiter.api.Test;

public class WrapperTest {
	// 基本数据类型--->包装类:调用包装类xxx.valueOf(基本数据类型)
	// 应用场景：比如形参传入的对象要求是类对象，则需把基本数据类型转换为包装类
	@Test
	public void test1() {
		// 方法一：包装类 = xxx.valueOf(基本数据类型)
		int num1 = 10;
		Integer in2 = Integer.valueOf("123");
		Integer obj = Integer.valueOf(num1);// jdk1.9之后官方推荐

		Boolean b1 = Boolean.valueOf("true123");// false

		// 方法二、自动装箱
		int i1 = 1;
		Integer ii1 = i1;

	}

	// 包装类--->基本数据类型:调用包装类的 对象.xxxValue()
	// 应用场景：包装类无法做加减乘除，我们就需要转换为基本数据类型
	@Test
	public void test2() {
		// 方法一：基本数据类型=对象.xxxValue()
		Integer in1 = Integer.valueOf("123");
		int i1 = in1.intValue();

		// 方法二：自动拆箱
		Integer ii1 = 1;
		int i3 = ii1;
	}

	// 包装类、基本数据类型--->String
	@Test
	public void test4() {
		// 方法一：连接运算
		int num1 = 10;
		String str1 = num1 + "";
		// 调用ValueOf()
		String str2 = String.valueOf(num1);
	}

	// String--->包装类、基本数据类型：调用包装类的parseXxx()
	@Test
	public void test5() {
		String str1 = "123";
		int num2 = Integer.parseInt(str1);
	}
}

应用示例

package myex4;

import java.util.Scanner;
public class VectorTest {
	public static void main(String[] args) {
		Vector v = new Vector();
		for(int i=0;i<4;i++) {
			System.out.println("请输入学生成绩：");
			Scanner score = new Scanner(System.in);
			Object s = score.nextInt();
			v.addElement(s);
		}
		System.out.println("插入元素结束");
		Object obj = v.elementAt(0);
		System.out.println(obj);
		
		int a = (int) obj;
		System.out.println(v.scoreGrade(a));
	}
}


class Vector{
	
	int[] score = new int[5];
	int total = 0;
	public void addElement(Object obj) {
		score[total++]=(int) obj;
	}
	
	public Object elementAt(int index) {
		Object obj = score[index];
		return obj;
	}
	 public int size() {
		 return total;
	 }
	 
	 public char scoreGrade(int s) {
		 int max=score[0];
		 for(int i=1;i<total;i++) {
			 if(score[i-1]<score[i]) {
				 max = score[i];
			 }
		 }
		 if (max-s<10) {
			 return 'A';
		 }else if(max-s<20) {
			 return 'B';
		 }else if(max-s<30) {
			 return 'C';
		 }else {
			 return 'D';
		 }
	 }
}

Static关键字

static 修饰属性

在这里插入图片描述

注意static常和final搭配使用

package myex4;

public class StaticTest {
	public static void main(String[] args) {
		Chinese c1 = new Chinese();
		c1.name="张三";
		c1.age=12;
		Chinese c2 = new Chinese();
		c2.name="张一";
		c2.age=13;
		c2.nation="China";
		System.out.println(c1.nation);
		System.out.println(Chinese.nation);
	}
}

class Chinese{
	String name;
	int age;
	static String nation;
}

类变量和实例变量内存解析

在这里插入图片描述

static修饰方法

package com.atguigu.contact;

import org.junit.jupiter.api.Test;

public class WrapperTest {
	@Test
	public void test1() {
		Person1.show();
		Person1 p = new Person1();
		p.eat();
	}
}


class Person1{
	int age;
	String name;
	
	public void eat() {
		System.out.println("人吃饭。");
		show();
	}
	
	public static void show() {
		System.out.println("人走路。");
		//eat();
	}
	
}

在这里插入图片描述

单例设计模式

在这里插入图片描述

  • 饿汉式设计模式
package com.atguigu.p2.bean;
/*
 單例設計模式
 1、所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
 */
public class SigletonTest1 {
	public static void main(String[] args) {
		Bank  bank1 = Bank.getInstance();
		Bank  bank2 = Bank.getInstance();
		System.out.println(bank1==bank2);//true
	}
}

//饿汉式（上来就New一个对象）
class Bank{
	//私有化类的构造器
	private Bank() {

	}
	//内部创建类的对象
	//要求此对象必须声明为静态的
	private static Bank instance = new Bank();
	
	//提供公共静态方法，返回类的对象
	public static Bank getInstance() {
		return instance;
	}
}

在这里插入图片描述

  • 懒汉式（啥时用对象，啥时造对象）
package com.atguigu.p2.bean;
/*
 單例設計模式
 1、所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
 */
public class SigletonTest1 {
	public static void main(String[] args) {
		Bank  bank1 = Bank.getInstance();
		Bank  bank2 = Bank.getInstance();
		System.out.println(bank1==bank2);//true
	}
}

//懒汉式
class Bank{
	//私有化类的构造器
	private Bank() {

	}
	//声明当前类对象，没有初始化
	//此对象声明为static
	private static Bank instance = null;
	
	//声明public、static的返回当前类对象的方法
	public static Bank getInstance() {
		if (instance == null) {
			instance = new Bank();
		}
		return instance;
	}
}
  • 饿汉式和懒汉式的区别
  • 单例模式优点
    在这里插入图片描述
  • 单例模式具体应用场景
    在这里插入图片描述

Main方法怎么在运行时传入数据

package myex4;

public class StaticTest {
	public static void main(String[] args) {
		for(int i=0;i<args.length;i++) {
			System.out.println("*****"+args[i]);
			int num2 = Integer.parseInt(args[i]); 
			System.out.println("^^^^^"+args[i]);
		}
		
	}
}

首先编译，生成字节码文件
选择Run As -->Run Configurations
在这里插入图片描述

代码块

在这里插入图片描述
在这里插入图片描述

final关键字

  • final修饰类
    在这里插入图片描述
    -修饰变量和方法
    在这里插入图片描述

      • final修饰属性
        显示初始化、代码块中赋值、构造器中初始化（若构造器有n个，则每个构造器都要给常量赋值），不能使用默认初始化
package com.atguigu.p2.bean;

class Bank {
	// final修饰属性
	//1、显式初始化
	final int ACCOUNT = 10;
	final int LEFT;// 常量
	final int RIGHT;

	// 2、代码块赋值
	{
		LEFT = 1;
	}

	// 3、构造器中初始化,所有構造器中都要初始化
	public Bank() {
		RIGHT = 2;
	}

	public Bank(int n) {
		RIGHT = n;
	}
}
    • 修饰局部变量
//final修饰方法体里的局部变量
class A{
	
	public void show() {
		final int NUM = 10;
	}
	
	public void show(final int num) {
		//意义是在方法体内不可以对形参进行修改，只可以调用。
		//例如num++是不对的，它对num进行了修改
		final int NUM = num;
	}
}

在这里插入图片描述

抽象类和抽象方法

在这里插入图片描述
在这里插入图片描述

package Array_ex;

public class AbstractTest {
	
	//一旦person类抽象，不可实例化
//	Person p1 = new Person();
//	p1.eat();
}


abstract class Person{
	
	String name;
	int age;
	
	public Person() {
		
	}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	
	public void eat() {
		System.out.println("人吃饭");
	}
	
	//抽象方法，没有方法体
	public abstract void walk();
	
}


class Student extends Person{
	
	//子类调用父类构造器
	public Student(String name,int age) {
		super(name,age);
	}
	
	public void walk() {
		System.out.println("我重写一下抽象方法");
	}
}

抽象在开发中的必要性

  • 开发中可以提示你对子类方法进行重写
    在这里插入图片描述
    在这里插入图片描述

abstract使用的注意点

在这里插入图片描述

抽象类和多态，自己领悟

匿名子类

public class AbstractTest {
	
	//匿名对象
//	new Student().walk();
	
	
	//创建一个匿名子类的对象
	Person p = new Person() {

		@Override
		public void walk() {
			
		}
		
	};
}

抽象应用：模版方法设计模式

在这里插入图片描述

package Array_ex;

import java.util.Arrays;

/*
 * 模版方法设计模式
 */
public class TemplateTest {
	public static void main(String[] args) {
		MyCode m = new MyCode();
		m.spendTime();

	}

}

abstract class Template {
	// 测试一段代码的运行时间
	public void spendTime() {
		long start = System.currentTimeMillis();
		this.code();
		long end = System.currentTimeMillis();
		System.out.println("程序运行时间：" + (end - start));
	}

	public abstract void code();
}

class MyCode extends Template {

	@Override
	public void code() {
		int[] arr = new int[] { 1, 4, 3, 2, 9 };
		for (int j = 0; j < arr.length; j++) {
			for (int i = 1; i < arr.length-j; i++) {
				if (arr[i] > arr[i - 1]) {
					int temp = arr[i];
					arr[i] = arr[i - 1];
					arr[i - 1] = temp;
				}
			}
		}
		System.out.println("排序后的数组：" + Arrays.toString(arr));

	}

}

接口

在这里插入图片描述

  • 示例
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package Array_ex;

public class InterfaceTest {
	public static void main(String[] args) {
		Plane p = new Plane();
		p.fly();
	}
	
	
}

interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;//书写时可以省略public static final
	
	//抽象方法
	public abstract void fly();
	void stop();//省略了public abstract
}

interface Attack{
	void attack();
}
class Plane implements Flyable,Attack{

	@Override
	public void fly() {
		System.out.println("起飞");
	}

	@Override
	public void stop() {
		System.out.println("停止");
	}

	@Override
	public void attack() {
		System.out.println("打你");
		
	}
	
}

在这里插入图片描述

接口应用示例

在这里插入图片描述


//USB接口示例
/*体现了多态，匿名接口等*/
package Array_ex;

public class USBTest {
	
	public static void main(String[] args) {
		//非匿名接口的匿名对象
		run(new UDisk());
		//匿名接口的匿名对象
		run(new USB() {

			@Override
			public void start() {
				System.out.println("手机开始工作");
				
			}

			@Override
			public void end() {
				System.out.println("手机停止工作");
				
			}});
	}
	//多态
	public static void run(USB u) {
		u.start();
		u.end();
	}
}

interface USB{
	void start();
	void end();
}

class UDisk implements USB{

	@Override
	public void start() {
		System.out.println("U盘开始工作");
		
	}

	@Override
	public void end() {
		System.out.println("U盘结束工作");	
	}
}

class Mp3 implements USB{
	@Override
	public void start() {
		System.out.println("MP3开始工作");
		
	}

	@Override
	public void end() {
		System.out.println("MP3结束工作");	
	}
}

代理模式

在这里插入图片描述

在这里插入图片描述

package Array_ex;

//import sun.nio.ch.Net;

public class NetworkTest {
	public static void main(String[] args) {
		Server s = new Server();
		ProxyServer p = new ProxyServer(s);
		p.browse();
	}
}

interface NetWork{
	public void browse();
}

//被代理类
class Server implements NetWork{

	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	}
	
}

//代理类
class ProxyServer implements NetWork{
	private NetWork work;
	
	
	
	public ProxyServer(NetWork work) {
		this.work = work;
	}

	public void check() {
		System.out.println("联网前检查工作");
	}

	@Override
	public void browse() {
		work.browse();
	}
	
}

工厂模式

了解即可
在这里插入图片描述

  • 接口中定义的静态方法只能接口自己调用。
  • 可以通过实现类的对象来调用接口的默认方法。
  • 若实现类重写了接口默认方法，则调用时调用的是重写方法。
  • 若子类（实现类）继承的父类和实现的接口中有同名同参数方法，若子类（实现类)没有重写该方法，则调用的是父类方法。
  • 实现类实现了多个接口，这些接口具有同名同参数方法，则调用该方法时会报错。

内部类

在这里插入图片描述
在这里插入图片描述


public class Inner {
	
	public static void main(String[] args) {
		//创建Dog实例（静态的成员内部类）
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例（静态的成员内部类）
		Person p = new Person();
		Person.Bird b = p.new Bird();


	}
	
}


class Person{
	String name;
	
	public void eat() {
		System.out.println("人吃饭");
	}
	//静态成员内部类
	static class Dog{
		String name;
		public void show() {
			System.out.println("狗");
		}
	}
	//非静态成员内部类
	final class Bird{
		String name;
		public Bird() {
			Person.this.eat();
		}
		
	}
	
	public void method() {
		//局部内部类
		class AA{
			
		}
	}
}
hellobigorange
关注
专栏目录
java是面向对象还是面向过程_Java面向对象编程和面向过程编程的区别
weixin_42298876的博客
02-12 4507
Java面向对象编程和面向过程编程的区别本章节目标：了解面向对象，知道类和对象的区别，会进行类的定义。知识框架：Java面向对象编程和面向过程编程的区别“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想，简称OP。“面向过程”也可称之为“面向记录”编程思想，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。所以面向过...
java面向对象编程总结
weixin_64926930的博客
04-29 1508
在经过十周的java学习后，我对于原本一窍不通的课程又有了新的理解，它也并不是原本我不认识之前高冷的模样，我在慢慢的接触它，认识它，了解它。但现在为止，我对于我所学习的java中的“面向对象编程”做一个个人总结，其中观点仅代表个人，如有错误，敬请纠正。 在我所学习的教材中，将“面向对象编程”分为1,2,3三个章节，我也将我所学习的内容分为三个点来进行总结。 面向对象编程1 什么是面向对象 在这个章节里面，我们知道了什么是面向对象，如果用一个比喻来说的话，面向对象就像是养花一样，买个花瓶，再买束鲜花，不喜
学习Java的你，真的会面向对象编程吗？
Designer 小郑的技术博客
07-19 8493
学习Java的你，真的会面向对象编程吗？本文主要讲解什么是面向对象，以及如何在Java中实现面向对象编程，欢迎您前来学习！
Java(老白再次入门) - 面向对象编程(上)
Syntactic Sugar
06-04 447
本系列文章均为尚硅谷资源！如有侵权，我将立即删除！ Java基础知识图解 学习面向对象内容的三条主线 Java类及类的成员 面向对象的三大特征 其它关键字 1.面向过程与面向对象 面向过程(POP) 与 面向对象(OOP) 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的 是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类.
Java实现面向对象编程
热门推荐
GHHCNGC的博客
07-17 2万+
目录 第1章... 10 抽象和封装... 10 1.1用面向对象设计电子宠物系统... 14 1.1.1为什么使用面向对象... 14 1.1.2使用面向对象进行设计... 15 1.2通过创建对象实现领养宠物功能... 17 1.2.1创建类的对象... 17 1.2.2构造方法及其重载... 23 1.2.3常见错误... 28 1.3使用封装优化电子宠物系统的类... ...
java面向对象编程思想的理解
寻寻觅觅的专栏
10-05 1万+
1、我们总说java是一门面向对象编程的语言，那什么是面向对象呢？ 我是这样理解的，对象是事物存在的实体，现实中，随处可见的事物便是对象，如人类、书桌、计算机、高楼大厦等。人类解决问题的方式总是将复杂的事物简单化，于是就会思考这些对象都是由哪些部分组成的。通常都会将对象划分为两个部分，即动态部分与静态部分。静态部分，顾名思义就是不能动的部分，这个部分被称为“属性”，任何对象都会具备其自身属性，如
什么是面向对象编程（Java）
DICA的SEOer专栏
03-17 1051
Java中的多态是通过方法重载和方法重写来实现的，方法重载是指在一个类中定义多个同名方法，但参数列表不同，方法重写是指在子类中重写父类的方法，从而实现不同的行为。在Java面向对象编程中，类是创建对象的模板，它定义了对象的属性和行为。Java面向对象编程是一种编程范式，它的核心思想是将程序中的数据和操作数据的方法组织成一个相互依存的对象集合，并通过对象间的交互来实现程序的功能。在Java面向对象编程中，对象是程序的基本单元，每个对象由数据和操作数据的方法组成，数据表示对象的状态，方法表示对象的行为。
Java面向对象浅谈
编程界明世隐的博客
12-06 5044
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java 面向对象编程核心概念
Jacks丶的博客
09-02 1345
Java 面向对象编程的核心概念。
JAVA 2面向对象程序设计(习题参考答案1-8).rar_Java 8_java 习题_java 习题_面向对象_面向对象程
09-20
理解如何声明、实例化和使用类与对象是学习面向对象编程的基础。 2. **封装**：封装是隐藏对象内部细节并提供公共接口来访问数据的方法。在Java中，通过访问修饰符（如public, private, protected）实现封装，这有...
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
面向对象编程（Java）.pdf
06-27
Java是一种广泛使用的面向对象编程语言，它封装了数据和操作数据的行为，并支持继承和多态特性，使得Java程序可以高度模块化和复用。在Java中，面向对象编程（OOP）的三大基本特性是封装、继承和多态。 封装是面向...
漫画面向对象编程 Java
06-16
借助于漫画展示的形式，面向对象的简、由类创建一个对象的方法、类的编写与对象的创建、类的构造函数、类的方法、修饰符、... 可以在轻松幽默的氛围中对面向对象编程产生浓厚的兴趣，从而为后续的编程进阶树立信心。
Java面向对象编程练习题.pdf
最新发布
05-22
Java面向对象编程练习题 本资源摘要信息涵盖了 Java 面向对象编程的基础知识，通过三个练习题，展示了 Java 编程语言的基本概念和应用。 练习题 01: 类的成员变量 本练习题展示了 Java 中类的成员变量的概念。类 ...
Java面向对象编程练习题（28题集）
lijiaxuan_的博客
03-16 2万+
【练习题】01.类的成员变量 猜数字游戏一个类A有一个成员变量v有一个初值100。定义一个类对A类的成员变量v进行猜。如果大了则提示大了小了则提示小了。等于则提示猜测成功。 import java.util.*; public class lianxi { public static void main(String[] dsa) { A a=new A(); Scanner input=new Scanner(System.in); while (1==1)
项目三——开发团队调度软件
qq_34229228的博客
12-08 1823
一、需求说明
JAVA学习
qq_34229228的博客
10-13 570
文章目录一、计算机基础 一、计算机基础 1、计算机包括硬件和软件两个部分。 2、物联网：给万物一个IP，通过互联网连接万物。 3、冯诺依曼结构：输入设备、输出设备、CPU(运算器、控制器)、存储器。 4、bit和byte： bit是计算机的最小存储单位，存0或存1； byte是计算机最基本的存储单元，1byte=8bits 1KB=1024B 1MB=1024KB 1GB=1024MB 1TB=1024GB 5、内存（RAM） CPU所使用的数据都来自于内存，不论是软件程序还是文件数据，都必须读入内存后
Java面向对象编程详解
"Java的面向对象编程主要讲解了面向对象编程的基本概念、对象的状态与行为、类和对象的关系，以及面向对象编程与面向过程编程的区别。由知名讲师孙鑫进行讲解，提供了相关的学习资料下载链接。" 在编程领域，Java是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hellobigorange

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值