java听课笔记8面向对象（下）

最新推荐文章于 2022-05-15 20:14:54 发布
最新推荐文章于 2022-05-15 20:14:54 发布
阅读量298 收藏
点赞数 1
分类专栏： Java基本功
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35069481/article/details/90748188
版权

课程大纲

  1. 继承的基本概念
  2. 继承的限制
  3. 子类的实例化过程
  4. 方法的重写
  5. super 关键字
  6. 继承的应用示例
  7. final关键字
  8. 抽象类
  9. 接口
  10. 多态性
  11. instanceof关键字
  12. 抽象类应用-模版方法模式
  13. 接口应用-策略模式
  14. Object类
  15. 简单工厂模式
  16. 静态代理模式
  17. 适配器模式
  18. 内部类
  19. 数据结构之链表
  20. 基本数据类型 包装类
  21. 包与访问修饰符

继承的基本概念

继承是从已有的类中创建新类的过程
继承一个父类，只能继承非私有的数据（属性和方法）

  1. 继承是面向对象三大特征之一
  2. 被继承的类称为父类（超类），继承父类的类称为子类（派生类）
  3. 继承是指一个对象直接使用另一个对象的属性和方法。
  4. 通过继承可以实现代码重用在这里插入图片描述
    语法：

[访问权限]class 子类名 extends 父类名｛
类体定义；
｝

示例：
在这里插入图片描述
protected（受保护的访问权限修饰符，用于修饰方法和属性，使用protected修饰的属性和方法可以被子类继承）
在这里插入图片描述
继承的限制约定：

  1. Java只能实现单继承(不能既继承狗，又继承猫)
  2. 允许多层继承，既一个子类可以有一个父类，这个父类还可以有其他父类。
  3. 继承只能继承非私有的属性和方法
  4. 构造方法不能被继承
  5. 创建子类对象时，父类的构造方法也会被调用，因为子类需要父类的数据，那么就要通过父类的构造方法来初始化数据
  6. 创建子类对象时会调用父类的默认构造方法，父类没有默认构造方法也要强行凑参数

补充说明：问，Java构造函数能否被继承，为什么？
答：不能，因为子类继承父类的时候，先运行父类的构造函数；具体的说就是运行父类时就会先“调用”父类的构造函数，注意“调用”和继承不是一个含义，实质上是“自动运行”。
继承的含义其实是“扩展”，子类完全没有必要扩展父类的构造函数，因为反正每次调子类的时候都会“自动运行”它父类的构造函数，如果真的需要子类构造函数特殊的形式，子类直接修改或重载自己的构造函数就好了
“调用”一个类有“继承”和“组合（说白了new一个类）”两种方式，当你“调用”一个类的时候就会“自动运行”他的“构造函数”

继承小结

  1. 继承是发生在多个类之间的
  2. 继承使用关键字extends
  3. Java只能单继承，允许多层继承
  4. 被继承的类叫做父类（超类），继承父类的泪叫做子类（派生类）
  5. 在父类中的非私有方法和属性可以被子类继承
  6. protected（受保护的访问权限修饰符），修饰的属性或方法可以被子类继承
  7. 构造方法不能被继承
  8. 创建对象会调用构造方法，调用构造方法不一定就是创建对象。例如创建homedog对象，会调用homedog和dog构造方法，但调用dog构造方法并没有创建dog对象
  9. 实例化子类对象，会先调用父类的父类的构造方法，如果父类中没有默认的构造方法，那么子类必须显示的通过super(…)来调用父类的带参构造方法。super也只能在子类构造方法在的第一句。

举例子：

package test;import java.util.Arrays;
import java.util.Scanner;

public class test{
	
	public static void main(String[] args){
		
	}
}
class Dog{
	protected String name;
	private String sex;
	//Dog 有参构造函数，
	//子类调用时发现没有无参构造函数，只能强行调用有参构造函数初始化了
	Dog(String name,String sex){
		this.name=name;
		this.sex=sex;
	}
}


class HomeDog extends Dog{
	
	//初始化
	public HomeDog(String name) {
		super(name, "傻狗");
	}
}


class HuskyDog extends Dog{
	
	public HuskyDog(){
	//初始化 
		//即使啥参数不需要，也要强行弄俩参数
		super("娘子","啊哈");//只能放在第一句
	}
}

继承的好处

  1. 提高代码的复用性
  2. 提高代码的维护性
  3. 让类与类之间产生关系，是多态的前提

继承的缺点
增强了类与类之间的耦合性

开发原则：高内聚，低耦合

3.子类的实例化过程

在子类进行实例化操作的时候，首先会让琦父类进行初始化操作。之后自己再进行实例化操作。

子类实例化过程：
子类实例化会先调用父类的构造方法
如果父类中没有默认的构造方法，在子类构造方法中必须显示的调用父类的构造方法

结论
构造方法只是用于初始化类的字段以及执行一些初始化代码
调用构造方法并不代表会生成对象

4.方法的重写

方法重写（overriding method）
在Java中 ，子类可以继承父类的方法，而不需要编写相同的方法。但有时候子类并不想原封不动地继承父类的方法，而是想做一定的修改，这就需要才有方法的重写，方法重写又称方法覆盖。在子类和父类中，重写方法后，在调用中，以创建方法的对象 类型为准，会调用谁的方法

package test;
import java.util.Arrays;
import java.util.Scanner;
public class test{
	
	public static void main(String[] args){
		Dog dog=new Dog();
		dog.eat();
		HuskyDog husky=new HuskyDog();
		husky.eat();
	}
}

class Dog{
	Dog(){}
	public void eat(){
		System.out.println("我是Dog,我会吃");
	}
}

//重写父类方法，但没有new类对象，因此没被调用
class HomeDog extends Dog{
	public void eat(){
		System.out.println("我是家狗，我会吃");
	}
}

//重写父类的方法；并且哈士奇对象来调用
class HuskyDog extends Dog{
	public void eat(){
		System.out.println("我是哈士奇，我会吃");
	}
}

/输出结果：
我是Dog,我会吃
我是哈士奇，我会吃/

关于方法重写的一些特性：

  1. 发生在子父类中，方法重写的两个返回值，方法名，参数列表必须完全一致（子类重写父类的方法）
  2. 子类抛出的异常不能超过父类相应方法抛出的异常（子类异常不能大于父类异常）
  3. 子类方法的访问级别不能低于父类相应方法的访问级别（子类访问级别不能低于父类访问级别）
  4. 父类中的方法若使用private，static，final任意修饰符，那么不能被子类重写

为什么要重写方法？或者 方法重写的目的是什么？
若子类从父类中继承过来的方法，不能满足子类特有需求时，子类就需要重写父类中相应的方法，方法的重写也是程序扩展的体现

面试题：overloading 与 overriding的区别？
overloading ：方法的重载，发生在同一个类中。方法名相同，参数列表不同，与返回值无关
overriding：方法的重写，发生在子父类中，方法名相同，参数列表相同，返回值相同（三同）
子类的访问修饰符大于或等于父类的修饰符，子类的异常声明必须小于或等于父类的异常声明。如果方法被private static final修饰，那么不能被重写

5.super关键字

super可以完成以下的操作：

  1. 使用super调用父类中的属性，可以从父类实例处获得信息

         class HuskyDog extends Dog{
    	//super.属性  表示调用父类的属性，如果是继承过来的属性，super可以省略
    	protected void println (super.name+"我是哈士奇");
    }

  2. 使用super调用父类中的方法，可以委托父类对象完成某件事情

     class HuskyDog extends Dog{
	public void eat(){
		//调用父类的吃饭方法
		super.eat();
		System.out.printf("我是子类的吃饭");
	}
}

  3. 使用super调用父类中的构造方法（super（实参形式）），必须在子类构造方法的第一条语句，调用父类中的构造方法，若不显示的写出来，默认调用父类的无参构造方法，比如：super（）；

    public HuskyDog(){
	//初始化 
		//即使啥参数不需要，也要强行弄俩参数
		super("娘子","啊哈");//只能放在第一句
	}

this表示当前对象
使用super来调用父类的而属性，方法，和构造方法。

6.继承的应用示例

实现一个化妆品商城中的化妆品管理

  1. 定义一个化妆品类（Cosmetic）；name品牌,type进口或国产 ,price单价
  2. 定义一个化妆品管理类（CosmeticManager）
    （1）实现进货功能
    （2）可以输出所有化妆品信息 的功能
  3. 使用继承实现一个可按单价排序输出所有化妆品的功能
  4. 使用继承实现一个只输出 进口 化妆品的功能
package test;
import java.util.Arrays;
import java.util.Scanner;
public class test{
	
	public static void main(String[] args){
		//可以继承属性和方法，但参数不能继承
		CosmeticManager cm=new CosmeticManager ();
		SortCosmeticManager scm=new SortCosmeticManager ();
		ImportCosmaticManager icm=new ImportCosmaticManager ();

		cm.add(new Cosmatic("香奈儿","中国",100));
		cm.add(new Cosmatic("大宝","中国",200));
		cm.add(new Cosmatic("欧莱雅","外国",180));
		cm.add(new Cosmatic("大白兔","外国",60));
		
		scm.add(new Cosmatic("香奈儿","中国",100));
		scm.add(new Cosmatic("大宝","中国",200));
		scm.add(new Cosmatic("欧莱雅","外国",180));
		scm.add(new Cosmatic("大白兔","外国",60));
		
		icm.add(new Cosmatic("香奈儿","中国",100));
		icm.add(new Cosmatic("大宝","中国",200));
		icm.add(new Cosmatic("欧莱雅","外国",180));
		icm.add(new Cosmatic("大白兔","外国",60));
		
		System.out.println("-------原样输出-------");
		cm.printInfo();
		System.out.println("--------价格升序输出------");
		scm.printInfo();
		System.out.println("-------只输出外国-------");
		icm.printInfo();

	}
}

//化妆品管理类
class CosmeticManager{
	protected Cosmatic[] cs=new Cosmatic[4];
	protected int count;//定义下标
	  
	//进货功能
	public void add(Cosmatic c){
		int size=cs.length;
		if(count >=size){
			int newlen=size*2;
			cs=java.util.Arrays.copyOf(cs, newlen);
		}
		cs[count]=c;
		count++;	
	}
	
	//输出所有产品方法
	public void  printInfo(){
		for(int i=0;i<count ;i++){
			System.out.println(cs[i].getInfo());
		}
	}
}


//可按单价排序的化妆品管理类
class SortCosmeticManager extends CosmeticManager{
	//排序输出所有产品
	public void printInfo(){
		Cosmatic[] temp=java.util.Arrays.copyOf(cs, count);
		
		Cosmatic c=null;
		for (int i=0;i<temp.length-1;i++){
			//length-1是为了下标从零开始，不加等于号是因为最后一轮不用比
			for(int j=0;j<temp.length-1-i;j++){
				if(temp[j].getPrice()>temp[j+1].getPrice()){
					c=temp[j];
					temp[j]=temp[j+1];
					temp[j+1]=c;
				}
			}
		}
		for(Cosmatic cosmatic:temp){
			System.out.println(cosmatic.getInfo());
		}
	}
	
} 

//
class ImportCosmaticManager extends CosmeticManager {
	ImportCosmaticManager(){}
	public void printInfo(){
		for(int i=0;i<count;i++){
			//比较两个字符串的值是否相等，不能使用==，因为等号是比较地址，比价值用equals
			//注意！！是"字符串".equals()不能忘记点
			//确定的放前面，避免空指针报错
			if("外国".equals(cs[i].getType()))
			{
				System.out.println(cs[i].getInfo());
			}
		}
	}
	
	
}

//化妆品类
class Cosmatic {
	private String name;//品牌
	private String type;//进口或者国产
	private int price;//单价
	
	
	//构造方法
	public void Cosmatic(){}
	public Cosmatic (String name ,String type,int price){
		this.name =name;
		this.type=type;
		this.price=price;
	}

	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setType(String type){
		this.type=type;
	}
	public String getType(){
		return type;
	}
	public void setPrice(int price){
		this.price=price;
	}
	public int getPrice(){
		return price;
	}
	public String getInfo(){
		return "牌子是"+name+"的化妆品产自"+type+"，价格是"+price+"元人民币";
		
	}
}

7.final关键字

使用final关键字声明一个常量

  1. 使用final关键字声明一个常量 修饰属性或修饰局部变量（最终变量），也称为常量。

    public class test1{
	//未来用10的时候，都可以用PERSON_NUM表示
	//固定的值没必要申请对象改，所以必须定义成静态static
	static final int PERSON_NUM=10;
	public static void main(String[] args){
		
		System.out.println(test1.PERSON_NUM);

	}
}

常量类

//常量必须在构造器或者定义时初始化
public class test1{
	public static void main(String[] args){
		
		System.out.println("此为在定义时初始化："+Constant.PERSON_NUM);
		System.out.println("此为在构造器中初始化："+FinalClass.DAY_NUMBER);

	}
}

//常量类（工具类） 

class Constant{
	//要静态,此为在定义时初始化
	public  final static int PERSON_NUM=10;//人数

}

class FinalClass{
	//不能写静态，因为要在在构造器中初始化
	public final int DAY_NUMBER ;

	public FinalClass(){
		  DAY_NUMBER = 22;
	}

}
  1. 使用final关键字声明一个方法 该方法为最终方法，且只能被子类继承，但是不能被子类重写
  2. 使用final关键字声明一个类 该类就转变为最终类，没有子类的类，final修饰的类无法被继承
  3. 在方法参数中使用final，在该方法内部不能修改参数的值（再内部类中详解）
    在这里插入图片描述

8.抽象类

抽象类的基本概念：

  1. 很多具有相同特征和行为的对象可以抽象为一个类；很多具有相同特征和行为的类可以抽象为一个抽象类。

  2. 使用abstract关键字声明的类为抽象类。
    在这里插入图片描述

    public class test1{
	public static void main(String[] args){
		Man m=new Man();
		m.eat();
		m.move();
	}
}

abstract class Anmal{
	public abstract void move();//方法的声明，抽象方法只有声明没有实现
}


abstract class Person extends Anmal{
	public abstract void eat();
}

//继承抽象类的具体类必须实现所有的抽象方法
class Man extends Person{
//Man类要实现两个具体方法
	public void eat() {
		System.out.println("吃");
	}

	
	public void move() {
		System.out.println("运动");

	}
	
}

抽象类的规则：

  1. 抽象类可以没有抽象方法（可以有具体方法），有抽象方法的类必须是抽象类
  2. 非抽象类可以继承抽象类，但必须实现所有抽象方法
  3. 抽象类可以继承抽象类，可以不实现父类抽象方法
  4. 抽象类可以有方法实现和属性
  5. 抽象类不能被实例化
  6. 抽象类不能声明为final
  7. 抽象类可以有构造方法

9.接口

接口的定义格式
接口和类是平级的，接口是一种规范，比方说合同。

interface 接口名称
｛
全局常量；
抽象方法；
｝

接口的概念

  1. 接口是一组行为的规范··定义，没有实现（jdk1.8默认方法）

         //jdk1.8可以定义默认方法，可以被所有实现类继承
    			public default void print(){
    				System.out.println("吃");
    			}

  2. 使用接口，可以让我们的程序更加有利于变化

  3. 接口是面向对象编程体系中的思想精髓之一

  4. 面向对象设计法则：基于接口编程

    package test;
public class test{
	
	public static void main(String[] args){
		Girl mm=new Girl("玛丽");
		mm.sleep();
		mm.eat();
		mm.run();
	}
}

interface IEat{
	//接口中只能定义抽象方法，和抽象类不一样，所有有一种简写方法
	//public abstract void eat();
	void eat();//在接口中定义的方法没有声明修饰符，默认为public abstract
	//在接口中定义一个常量
	//public static final int NUM=10;
	//同样也有简写
	int NUM=10;	
}

interface IRun {
	void run();
}


//接口允许多继承，类只能单继承
interface ISleep extends IEat,IRun{
	void sleep();
}


//具体类实现接口必须实现接口的所有方法
class Girl implements ISleep,IEat{
	private String name;
	public Girl(){}
	public Girl(String name){
		this.name =name;
	}
	public void sleep(){
		System.out.println("我爱睡觉");
	}
	public void eat(){
		System.out.println(name +"爱吃");
	}
	@Override
	public void run() {
		System.out.println("我爱跑");
		
	}
}
/*运行结果
我爱睡觉
玛丽爱吃
我爱跑*/

接口的使用规则：

  1. 定义一个接口，使用interface关键字
  2. 在一个接口中，只能定义常量，抽象方法，jdk1.8后可以定义默认的实现方法defaul
  3. 接口可以继承多个接口，extends XXX,XXX
  4. 一个具体类实现接口使用implements
  5. 一个类可以实现多个接口
  6. 抽象类实现接口可以不实现接口的方法
  7. 在接口定义的方法没有声明 访问修饰符，默认为public
  8. 接口不能有构造方法
  9. 接口不能被实例化

面向对象的设计原则

  1. 对修改关闭，对扩展开放
  2. 面向接口编程

10.多态性

多态是面向对象三大特征之一
什么是多态性？
对象再运行过程中的多种形态

多态性我们大概可以分为两类：

  1. 方法的重载和重写
  2. 对象的多态性

例如：
//用父类的引用指向子类对象（用打得类型去接受校对而类型，向上转型，自动转换）
Chicken home =new HomeChicken();

结论：
在编程时针对抽象类型的编写代码，称为面向抽象编程（或面向接口编程）
父类通常都定义为抽象类，接口

对象的多态性
对象的多态性是从继承关系中的多个类而来，
向上转型：将子类实例转化为父类引用

格式：父类 父类对象=子类实例；一>自动转换

以基本数据类型操作为例：int i=‘a’;
(因为char的容量比int小，所以可以自动完成)

**向下转型：**将父类实例转化为子类实例

格式：子类 子类对象=（子类）父类实例； 强制转换

以基本数据类型操作为例：char c=（char）94;
因为整型是4个字节比char2个字节要大，所以需要强制完成

package test;

public class test {

	public static void main(String[] args) {
		// 用父类的引用指向子类对象（用大的类型表示小的类型），自动转换（向上转型）
		Chicken hc = new HomeChicken("家鸡");
		// hc.eat();
		eat(hc);

		YeChicken yc = new YeChicken("野鸡");
		// yc.eat();
		eat(yc);
		
		JianJiaoChicken jjj = new JianJiaoChicken("野鸡");
		eat(jjj);

	}

	// 抽象（粒度 ） 面向抽象编程（面向接口编程）
	public static void eat(Chicken c) {
		System.out.println("鸡吃饭");
		c.eat();
		//错误示例JianJiaoChicken jjc=Chicken();
		JianJiaoChicken jjc=(JianJiaoChicken) c;
		jjc.song();
	}

}

// 鸡
abstract class Chicken {
	private String name;

	public Chicken() {
	}


	public Chicken(String name) {
		this.name = name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public abstract void eat();
}

// 家鸡
class HomeChicken extends Chicken {
	public HomeChicken() {
	}

	public HomeChicken(String name) {
		// super(name)等问题,就是完成父类的构造: 它实际上等同于: Super name = name;
		super(name);
	}

	public void eat() {
		System.out.println(this.getName() + "我爱吃小米");
	}

}

// 野鸡
class YeChicken extends Chicken {
	public YeChicken() {
	}

	public YeChicken(String name) {
		// super(name)等问题,就是完成父类的构造: 它实际上等同于: Super name = name;
		super(name);
	}

	public void eat() {
		System.out.println(this.getName() + "我爱吃虫子");
	}
}

// 再增加个尖椒鸡
class JianJiaoChicken extends Chicken {
	public JianJiaoChicken() {
	}

	public JianJiaoChicken(String name) {
		super(name);
	}

	public void eat() {
		System.out.println(this.getName() + "我不吃东西");
	}
	public void song() {
		System.out.println("我唱歌");
	}
}

多态性小结

  1. 方法的重载与重写就是方法的多态性表现
  2. 多个子类就是父类中的多种形态
  3. 父类引用可以指向子类对象，自动转换
  4. 子类对象指向父类引用需要强制转换（注意：类型不对会报异常）
  5. 在实际开发在尽量使用父类引用（更利于扩展）

11.instanceof关键字

instanceof是用于检查对象是否为指定的类型，通常在把父类引用强制转换成子类引用时要使用，以避免发生类型转换异常（ClassCastException）。
格式：

对象 instanceof 类型 --------返回boolean类型值

示例：

if(homeChicken  instanceof  Chicken){
		//....
}

该语句一般用于判断一个对象是否为某个类的实例，是返回ture，否返回false
if（子类对象 instanceof 子类类型）｛//成立的条件是对现象本身及对象的夫类型，都可以通过检验
子类类型 子类对象=（父类类型）负累对象；
子类对象.（子类方法）；
｝在这里插入图片描述
父类的设计法则
通过instanceof关键字，我们可以很方便的检查对象的类型，但如果一个父类的子类过多，这样的判断还是显得很繁琐，那么如何去设计一个父类哪？

  1. 父类通常情况下都设计为抽象类或接口，其中优先考虑接口，如接口不能满足才考虑抽象类。
  2. 一个具体类尽可能不去继承另一个具体类，这样的好处是无需检查对象是否为父类的对象

12。抽象类的使用一一模版方法模式（煎饼果子）

模版方法模式（Templete Method）：定义一个操作中的算法的骨架，而将一些可变部分的实现延迟到子类中。模版方法模式是的子类可以不改变一个算法的结构即可重新定义该算法的某些特定的步骤。

public class test1 {
	public static void main(String[] args) {
		UserManager um = new UserManager();
		um.action("admin", "add");
	}

	// 在Java中，类中的静态方法不能直接调用动态方法，主程序为public static class开头，所以不能直接调用BaseManager方法
	abstract static class BaseManager {

		public void action(String name, String menthod) {
			if ("admin".equals(name)) {
				excute(menthod);
			} else {
				System.out.println("你没有操作权限，请联系管理员");
			}

		}

		public abstract void excute(String menthod);
	}

	// 在Java中，类中的静态方法不能直接调用动态方法，主程序为public static class开头，所以不能直接调用UserManager方法

	public static class UserManager extends BaseManager {
		public void UserManager() {
		};

		public void excute(String menthod) {
			if ("add".equals(menthod)) {
				System.out.println("已经完成添加操作");
			}
			if ("del".equals(menthod)) {
				System.out.println("已经完成删除操作");

			}
		}
	}

}

13.接口应用一一策略模式（锦囊妙计）

策略模式（StrategyPattern）定义了一系列的算法，将每一种算法封装起来并可以相互替换使用，策略模式让算法独立于使用他的客户应用而独立变化。
OO设计原则：

  1. 面向接口编程（面向抽象编程）

  2. 封装变化

  3. 多用组合，少用继承
    在这里插入图片描述
    /* 自己写的
    1.创建了一个抽象类BaseService，用实体类UserService继承
    2.创建了一个接口ISave ，定义方法save()
    3.创建俩锦囊类FileSave和NetSave继承接口ISave，并定义save()方法
    4.*/
    package test;
    public class test {

    	public static void main(String[] args) {
		//小的放大里面
		BaseService user=new  UserService();
		//未来使用时可以替换，如
		//user.setiSave(new NetSave());
		user.setiSave(new FileSave());
		user.add("user");
	}
}



interface ISave {
	public void save(String data);
}

//锦囊一
class FileSave implements ISave {

	public void save(String data) {
		System.out.println("正在把数据保存到文件当中..." + data);
	}

}

//锦囊二
class NetSave implements ISave {

	public void save(String data) {
		System.out.println("正在把数据保存到网络当中..." + data);
	}

}



abstract class BaseService {
	private ISave iSave;
	
	public void setiSave(ISave iSave) {
		this.iSave = iSave;
	}
	
	public ISave getiSave() {
		return iSave;
	}
	
	public void add(String data){	
		System.out.println("检查数据合法性...");
		iSave.save(data);
		System.out.println("数据保存完毕...");

	}
}

class UserService extends BaseService{}

14.Object类

object类是类层次结构的根类（祖宗）
每个类都使用Object作为超类。所有的对象(包括数组)都实现这个类的方法
所有类都是object类的子类

public String toString()方法
返回该对象的字符串表示
通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明且移动的信息表达式。建议所有子类都重写此方法。

/*toString 	*/
package test;

public class test {

	public static void main(String[] args) {
		Student s = new Student(1, "博博",18);
		System.out.println(s.toString());
	}
}

class Student {
	public Student( int sid,String name, int age) {
		this.name = name;
		this.age = age;
		this.sid = sid;
	}

	public void Student() {
	}

	private String name;
	private int sid;
	private int age;

	// 重写Object类中的toString方法
	public String toString() {
		return "sid:" + sid + ",name:" + name + ",age:" + age;

	}

}

//运行结果：sid:1,name:博博,age:18

public boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。equals方法在非空对象引用上实现相等关系：
自反性
对称性
传递性
一致性

    /* 	*/
package test;

import java.lang.*;
public class test {

	public static void main(String[] args) {
		Student s1 = new Student(2, "贝贝", 19);
		//System.out.println(s1.toString());
		Student s2 = new Student(2, "贝贝", 19);
		//boolean b = s.equals(s2);
		System.out.println("student equals:"+s1.equals(s2));

		String str1 = new String("贝贝");
		String str2 = new String("博博");
		System.out.println(str1.equals(str2));

	}
}

class Student {
	public Student(int sid, String name, int age) {
		this.name = name;
		this.age = age;
		this.sid = sid;
	}

	public void Student() {
	}

	private String name;
	private int sid;
	private int age;

	// 重写Object类中的toString方法
	public String toString() {
		return "sid:" + sid + ",name:" + name + ",age:" + age;
	}

	// 重写equals方法，来实现两个对象的比较，值匹配
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Student) {
			Student s = (Student) obj;
			if (!this.name.equals(name)) {
				return false;
			}
			if (this.sid != s.sid) {
				return false;
			}
			if (this.age != s.age) {
				return false;
			}
			return true;
		}
		return false;
	}
}
//运行结果
student equals:true
false

protected void finalize()throwable
当垃圾回收器确定不存在对该对象的更多引用时，由对象回收器调用此方法，子类重写finalize方法，以配置系统资源或执行其他清除。

public final Class<?>getClass()
返回此Object的运行时类。获取该类在方法区的类信息

其他方法后续章节中详解

15.简单工厂模式

简单工厂模式是由一个工厂对象界定创建哪一种产品类的实例。简单工厂模式是工厂模式家族中 最简单最实用 的模式。
/*toString */
package test;

	public class test {
	
		public static void main(String[] args) {
			//使用者与被使用者之间，耦合，产生了依赖，当被使用者改变时，会影响使用者
			//使用工厂模式来降低两者的耦合
			Product phone=ProductFactory.getProduct("phone");
			if(null!=phone){
				phone.work();
			}
		}
	}
	
	//工厂类
	class ProductFactory {
		public static Product getProduct(String name){
			if ("phone".equals(name)){
				return new Phone();
				
			}else if ("computer".equals(name)){
				return new Computer();
			}else {
				return null;
			}
			
			
		}
	}
	
	interface Product {
		public void work();
	}
	
	class Phone implements Product {
		public void work() {
			System.out.println("手机开始工作...");
		}
	}
	
	class Computer implements Product{
		public void work(){
			System.out.println("电脑开始工作...");
		}
		
	}

在这里插入图片描述

16.静态代理模式

代理模式（Proxy）：为其他对象提供一种代理以控制之而过对象的访问

代理模式说白了就是“真实对象”的代表，再访问对象时引入一定程度 的间接性，因为这种间接性可以附加多种用途。在这里插入图片描述

	package test;
	
	public class test {
	
		public static void main(String[] args) {
			Action userAction = new UserAction();
	
			Actionproxy proxy = new Actionproxy(userAction);
			proxy.doAction();
		}
	}
	
	interface Action {
		public void doAction();
	}
	
	class UserAction implements Action {
		// 一些杂乱无章的方法可以单列出来代理
		public void doAction() {
			System.out.println("用户开始工作...");
		}
	}
	
	class Actionproxy implements Action {
		private Action target;// 被代理的对象
	
		Actionproxy() {
		}
	
		Actionproxy(Action target) {
			this.target = target;
		}
	
		// 执行操作
		public void doAction() {
			long startTime = System.currentTimeMillis();
			target.doAction();// 执行真正的业务
			long endTime = System.currentTimeMillis();
			System.out.println("共耗时" + (endTime - startTime));
		}
	
	}
	/*结果：
	    用户开始工作...
		共耗时0
	*/

17.适配器模式

适配器模式（Adapter）：将一个类的接口转换成客户希望的另一个接口，适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

oo设计原则：

  1. 面向接口编程（面向抽象编程）
  2. 封装变化
  3. 多用组合，少用继承
  4. 对修改关闭，对扩展开放

在这里插入图片描述

		package test;
		
		public class test {
		
			public static void main(String[] args) {
				PowerA powerA = new PowerAImpl();
				work(powerA);
		
				PowerB powerB = new PowerBImpl();
				Adapter adapter = new Adapter(powerB);
				work(adapter);
		
			}
		
			public static void work(PowerA a) {
				System.out.println("正在连接...");
				a.insert();
				System.out.println("工作结束...");
			}
		}
		
		interface PowerA {
			public void insert();
		}
		
		interface PowerB {
			public void connet();
		}
		
		// 适配器,要适配A才能把接口插到A里面去
		class Adapter implements PowerA {
			private PowerB powerB;
		
			public Adapter() {
			}
		
			public Adapter(PowerB powerB) {
				this.powerB = powerB;
			}
		
			public void insert() {
				powerB.connet();
			}
		
		}
		
		class PowerAImpl implements PowerA {
			public void insert() {
				System.out.println("电源A开始工作");
			}
		}
		
		class PowerBImpl implements PowerB {
			public void connet() {
				System.out.println("电源B开始工作");
			}
		}
	/*正在连接...
	电源A开始工作
	工作结束...
	正在连接...
	电源D开始工作
	工作结束...
		*/

适配器的第二种使用方法

interface Animal {
	public void sing();
	public void jump();
	public void rap();
	public void basketball();	
}

//如果我只想实现rap曾么办？

//适配器，抽象实现
abstract class AnimalFunction{
	public void sing(){};
	public void jump(){};
	public void rap(){};
	public void basketball(){};
}

class Man extends AnimalFunction{
	public void rap(){
		System.out.println("你看这个面，它又长又宽");
	}

}

18.内部类

内部类就是在一个类的而内部定义的类

成员内部类格式如下：

class Outer
{
class Inner{ }
}

编译上面的代码会产生两个文件：
Outer . class和Outer$Inner . class。

成员内部类
在外部创建成员内部类对象
内部类除了可以在外部类中产生实例化对象，也可以在外部类的外部来实例化。
那么，根据内部类生成的*.class文件：Outer I n n e r . c l a s s &quot; Inner.class &quot; Inner.class""符号子啊程序运行时将替换成“.”
所以，内部类的访问：通过“外部类.内部类”的形式表示。

Outer out =new Outer();//产生外部实例
Outer.Inner in =null;//声明内部类对象
In=out.new Inner();//实例化内部类对象

在这里插入图片描述
方法内部类
内部类可以作为一个类的成员之外，还可以把类返回值方法内定义。

注意

  1. 方法内部类只能在定义该内部类的方法内实例化，不可以在次方法外对其实例化。

  2. 方法内部类对象不能使用该内部类所在方法的非final局部变量
    在这里插入图片描述
    静态内部类
    在一个类内部定义一个静态内部类：
    静态的含义是该内部类可以像其他静态成员一样。没有外部类对象时，也能够访问他。不依赖于对象，静态嵌套类仅能访问外部类的静态成员和方法

    public class test {

	public static void main(String[] args) {
		Outer.Inner n = new Outer.Inner();
	}
}

class Outer {
	static class Inner {
	}
}

匿名内部类
匿名内部类就是没有名字的内部类。
匿名内部类的三种情况：

  1. 继承式的匿名内部类
  2. 接口式的匿名内部类
  3. 参数式的匿名内部类

在使用匿名内部类时，要记住以下几个原则：

  1. 不能有构造方法，只能有一个实例。

  2. 不能定义任何静态变量.静态方法。

  3. 不能是public,protected,private,static。

  4. 一定是在new后面的，用其隐含实现一个接口或继承一个类。

  5. 匿名内部类是局部的。使用局部内部类的所有限制都对其生效。

    package test;
		
public class test {

	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.print1();
		outer.print2();
		// 参数式匿名内部类
		outer.print3(new Eat() {
			public void eat() {
				System.out.println("参数式匿名内部类");
			}
		});
	}
}

// ......匿名内部类.......
// ......继承式匿名内部类.......
abstract class Cat {
	public abstract void eat();
}

class Outer {

	public void print1() {
		final Cat cat = new Cat() {
			public void eat() {// 大括号表示实现
				System.out.println("eat:继承式匿名内部类");
			}
		};// 特别注意这个分号
		cat.eat();
	}

	// ......接口式匿名内部类.......
	public void print2() {
		IEat eat = new IEat() {
			public void eat() {
				System.out.println("eat:接口式匿名内部类");
			}
		};
		eat.eat();
	}

	// ......参数式匿名内部类.......
	public void print3(Eat eat) {
		eat.eat();// eat方法见上面
	}
}

interface IEat {
	public void eat();
}

问题：局部内部类访问局部变量必须用final修饰，为什么？
当调用这个方法时，局部变量如果没有final修饰，他的生命周期和方法的生命周期是一样的，当方法被调用时会入栈，方法结束后即弹栈，这个局部变量也会消失，那么，如果局部内部类变量还没有马上消失，并企想用这个局部变量，显然已经无法使用了，如果用final修饰，则会在类加载的时候进入常量池。即使方法弹栈。常量池的常量还在，也就可以继续使用了

注意：在jdk 1.8中取消了这个特性，改为编译器默认添加final修饰符了。

内部类的作用
每个内部类都能独立的继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果内部类提供的可以继承多个具体或抽象的类的能力，一些设计和编程问题就很难解决，从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效的实现了“多重继承”。
如：

class A extends B{
			class C extends D{
			}
			class E extends F{
			}
}

在这里插入图片描述

18.递归（略）

19.数据结构之链表

一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，
而是在每一个节点存到是笑一个节点的指针（Pointer）。

链表与数组：线性数据结构

数组适合查找遍历，固定长度

链表适合插入删除，不宜过长，否则会导致遍历性能下降

package test;

public class test {

	public static void main(String[] args) {
		NodeManager nm = new NodeManager();
		System.out.println("......add.......");
		nm.add(5);
		nm.add(4);
		nm.add(3);
		nm.add(2);
		nm.add(1);
		nm.print();

		System.out.println("......find.......");
		System.out.println(nm.find(6));

		System.out.println("......del.......");
		nm.del(3);
		nm.print();

		System.out.println("......update.......");
		nm.update(2, 8);
		nm.print();
		
		System.out.println("......index.......");
		nm.insert(1, 9);
		nm.print();

	}
}

class NodeManager {
	private Node root;// 根节点。root已经是Node类型了
	private int currentIndex = 0;// 节点的 序号，每次操作从0开始

	// 添加
	public void add(int data) {
		// 如果 没有根节点，就把node(data)当做根节点，
		// 有的话，调用addNode(data)添加
		if (root == null) {
			root = new Node(data);
		} else {
			root.addNode(data);
		}
	}

	// 删除
	public void del(int data) {
		if (root == null) {
			return;
		}
		// 删除根节点
		if (root.getData() == data) {
			root = root.next;
		} else {
			// 不删除根节点，调用delNode(data)搜索根节点的下一个
			root.delNode(data);
		}
	}

	// 更新
	public boolean update(int oldData, int newData) {
		if (root == null) {
			return false;
		}
		if (root.getData() == oldData) {
			root.setData(newData);// 改的是根节点。直接setDate
			return true;
		} else {// 否则改的是里面的
			return root.updateNode(oldData, newData);
		}

	}

	// 打印所有
	public void print() {
		if (root == null) {
			return;
		} else {
			System.out.print(root.getData() + "->");
			// 为什么结果显示5->4->3->2->1->
			// 因为跑到这个的时候发现pritNode()调用发现data.next==null,但已经执行上面的语句了
			root.printNode();
			System.out.println();

		}
	}

	// 查找
	public boolean find(int data) {
		if (root == null) {// 连根节点都没有
			return false;
		} else {
			if (root.getData() == data) {
				return true;
			} else {
				return root.findNode(data);
			}
		}
	}

	// 插入(向索引之前插入)
	// 不知道插入第几个，所以要在前面设置一个变量
	public void insert(int index, int data) {
		if (index < 1)
			return;
		currentIndex = 1;// 每次都从1遍历
		if (index == currentIndex/* 要插入的是1位置 */) {
			Node newNode=new Node (data);
			
			/* 后插法 root.next=newNode;*/
			/*前插法*/
			newNode.next=root;
			/*然后root替换成新的值*/
			root=newNode;
		}else{
			root.insertNode(index, data);
		}
	}

	private class Node {
		private int data;
		private Node next;// 把当前类型作为属性

		// 构造方法
		public Node(int data) {
			this.data = data;
		}

		public void setData(int data) {
			this.data = data;
		}

		public int getData() {
			return data;
		}

		// 添加节点
		public void addNode(int data) {
			// 因为是root调用了当前方法，所以this是root,第二遍是root.next
			if (this.next != null) {
				// 如果不是链表尾巴，就遍历到最后一个后添加
				this.next.addNode(data);
			} else {
				// 如果是链表尾巴，就添加
				this.next = new Node(data);
			}
		}

		// 删除节点
		public void delNode(int data) {
			if (this.next != null) {
				// 刪除根节点下一个节点，前面已经判断过当前节点，此时应该判断下一节点
				if (this.next.data == data) {
					this.next = this.next.next;
					// 使用下面代码会多删除一位
					// this.next.next = this.next.next.next;
				} else {
					// 没找到，递归下一个
					this.next.delNode(data);
				}
			}

		}

		// 打印所有节点
		public void printNode() {
			if (this.next != null) {
				System.out.print(this.next.data + "->");
				this.next.printNode();
			}
		}

		// 查找节点是否存在
		public boolean findNode(int data) {
			if (this.next != null) {
				if (this.next.data == data) {
					return true;
				} else {
					return this.next.findNode(data);
				}
			} else {
				return false;
			}

		}

		// 修改节点
		public boolean updateNode(int oldData, int newData) {
			if (this.next != null) {// 很长一串
				if (this.next.data == oldData) {
					this.next.data = newData;
					return true;
				} else {
					return this.next.updateNode(oldData, newData);
				}
			}
			return false;

		}

		// 插入节点
		public void insertNode(int index, int data) {
			currentIndex++;
				if (index==currentIndex){
					Node newNode=new Node (data);
					newNode.next=this.next;
					this.next=newNode;
				}else{
					this.next.insertNode(index, data);
				}
		}
	}
}

20.基本数据类型包装类

在Java中有一个设计的原则“一切皆对象”。Java中的基本数据类型就完全不符合这种设计思想，因为八种基本数据类型并不是引用数据类型，所以Java为了解决这样的问题，jdk1.5之后引入了八种数据类型的包装类

八种数据类型分为两大类型：

  1. Number：Integer,Short,Long,Double,Float,Byte都是Number的子类，表示是一个数字。
  2. Object：Character,Blooean都是Object的直接子类。
基本数据类型包装类
intInteger
charCharacter
floatFloat
doubleDouble
booleanBoolean
byteByte
shortShort
longLong

装箱及拆箱操作
将一个基本数据类型转化为包装类，那么这样的操作称为装箱操作。将一个包装类转化为另一个基本数据类型，这样的操作称为拆箱操作。

方法描述
byteValue( )Byte–>byte
doubleValue( )Double–>double
floatValue( )Float–>float
intValue( )Integer–>int
longValue( )Long–>long
shortValue()Short–>short
package test;

public class test {

	public static void main(String[] args) {
		// 把基本数据类型转换为包装类，成为自动装箱
		Integer i1 = new Integer(10);
		// 把包装类转换为基本数据类型。称为自动拆箱
		int i2 = i1.intValue();

		Integer i3 = 10;// 建议这种方式

		// 构造一个字符串，字符串转化为int
		Integer i4 = new Integer("123");
		System.out.println(i4);// 运行结果：123

		//把数值字符串转换成int类型
		String num1 = "12";
		//建议parseInt()
		int i5 = Integer.parseInt(num1);

		int i6=Integer.valueOf(num1);
	}
}

转型操作
在包装类中，可以将一个字符串变为指定的基本数据类型，一般在输入数据时会使用较多。在Integer类中将String变为int型数据：public static int parseInt(String s)
在Float类中将String变为float型数据：public static float parseFloat(String s)

注意：转型操作时，字符串必须由数字组成
面试题：==比较的是地址，equals比较的才是值

		Integer x1 = new Integer(10);
		Integer x2 = new Integer(10);
		System.out.println(x1==x2);			//false，等号比较地址
		System.out.println(x1.equals(x2));	//true
		
		Integer x3 = new Integer(128);
		Integer x4 = new Integer(128);
		System.out.println(x3==x4);			//false
		System.out.println(x3.equals(x4));	//true

		Integer x5 = 127;/*java中把一个字节的常量当作享元，so 127是一个字节128不是*/
		Integer x6 = 127;
		System.out.println(x5==x6);			//true???享元模式!!!
		System.out.println(x5.equals(x6));	//true
		
		Integer x7 = 128;
		Integer x8 = 128;
		System.out.println(x7==x8);			//false
		System.out.println(x7.equals(x8));	//true

享元模式（Flyweight Pattern）它使用共享对象，来尽可能减少内存使用量以及分享资讯给更多的相似对象；它适用于当大量对象只是重复，因而导致无法令人接受的使用大量内存。通常对象中的部分状态可以分享。常见的而做法是把它们放在外部的数据结构，当需要使用时候再将它们传递给享元。

运用共享技术有效的支持大量细粒度的对象

21.包与访问修饰符

包用于对多个Java源文件的管理，就像我们的文件目录一样。
定义一个包：
package com. vince;
该语句只能出现在代码的第一句。
访问修饰符：

访问修饰符同一个类同包不同包子类不同包非子类
public√√√√
protected√√√
默认√√
private√

OO原则总结

  1. 开闭原则一个软件实体如类，模块和函数都应该对扩展开放，对修改关闭。
  2. 合成/聚合复用原则新对象的某些功能在已经创建好的对象里已实现，那么尽量用已有对象提供的功能，使之成为新对象的一部分，而不要再重新创建。
  3. 依赖倒置原则高层模块不应该依赖底层模块，二者都因该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。
  4. 接口隔离原则客户端不应该依赖他不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
  5. 迪米特法则一个对象应该对其他对象保持最少的了解
  6. 里氏替换原则所有引用基类的地方必须能够透明的而是用其子类的对象
  7. 单一职责原则不要存在多于一个导致类变更的原因，即一个类只负责一项职责
钢铁闪电
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java编程题】
javaYY_的博客
07-07 690
public class test1 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); f(n); } private static void f(int n) { if(n<0) return; if(n ==
Java 9新特性
qq_45554909的博客
12-16 274
官方提供的新特性列表:https://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-C23AFD78-C777-460B-8ACE-58BE5EA681F6 或参考 Open JDK http://openjdk.java.net/projects/jdk9/ 在线Oracle JDK 9 Documentation:https://docs.oracle.com/javase/9/ 一、JDK 和 JRE 目录结构的改变 ...
Cannot use ‘＜＞‘ with anonymous inner classes
pxyyoona的博客
05-15 1360
将Java环境由Java8改为Java9.
Java9|Java10|Java11新特性
飞奔的五花肉博客
01-08 504
文章目录Java9的新特性JDK 和 JRE 目录结构的改变模块化系统: Jigsaw -> ModularityJava的REPL工具： jShell命令接口的私有方法语法改进：钻石操作符使用升级语法改进：try语句String存储结构变更集合工厂方法：快速创建只读集合-便利的集合特性：of()增强的Stream APIJava10的新特性局部变量类型推断集合新增创建不可变集合的方法Java11的新特性新增了一系列字符串处理方法Optional 加强局部变量类型推断升级全新的HTTP 客户端API更
Java系列笔记第二章：面向对象(OOP)
soldersun的博客
06-15 327
第二章 : 面向对象(OOP) 成员变量和局部变量的区别 作用域不同：局部变量只能在方法体内使用，成员变量能在整个类内使用。 定义的位置不同：局部变量在方法体内定义，成员变量在类内定义。 初始值不同：局部变量使用必须手动初始化，成员变量如果不手动初始化，会被自动初始化为默认值。 内存中的位置不一样：局部变量在JVM栈中，成员变量在堆中。 生命周期不同：局部变量随方法结束被回收，成员变量随对象被回收而结束。 OOP三大特征：封装继承和多态 1. 封装 1.1 什么是封装 两种封装性的体现： 方法 ： 对
面向对象程序设计Java听课笔记
02-24
面向对象程序设计是计算机科学中的核心概念之一，Java语言作为其典型代表，广泛应用于软件开发。浙江大学翁恺老师的Java视频课程深入浅出地讲解了这一主题，这些笔记旨在帮助我们回顾和巩固Java开发的关键知识。 1....
java听课笔记[汇编].pdf
10-11
Java是一种广泛使用的编程语言，以其跨平台性、安全性、面向对象特性和易用性而闻名。在Java中，代码可以在任何支持Java虚拟机（JVM）的平台上运行，无需重新编译，这是因为JVM实现了“一次编译，到处运行”的理念。...
Java面向对象实战进阶
06-19
本教程是在课程“Java面向对象开发基础”的基础上的进阶部分，java基础课程部分免费。主要包括Java高级编程部分，包括：Java修饰符、抽象类和接口编程、Java常用类、集合、异常、多线程开发、IO流和文件、Java网络...
达内java课程听课笔记
09-15
Java是一种广泛使用的面向对象的编程语言，以其跨平台、高性能和强大的库支持而闻名。"达内java课程听课笔记"提供了对20天密集型Java培训课程的详细记录，涵盖了从基础到进阶的众多主题。以下是根据这些笔记可能涵盖...
【达内】听课笔记之二——JAVA
12-02
本节的听课笔记将深入探讨Java的核心概念和技术。 一、Java语言基础 1. 变量与数据类型：Java提供了基本数据类型（如int、float、char等）以及引用数据类型（如类、接口和数组）。变量是存储数据的容器，必须先...
Java编程思想第十章"内部类"的10.1和10.2小节的练习题
hi__study的博客
04-11 894
10.1小节只是讲如何创建一个类的内部类，因而只记录一下练习题。 练习题1：编写一个名为Outer的类，它包含一个名为Inner的类。在Outer中添加一个方法，它返回一个Inner类型的对象。在main()中，创建并初始化一个指向某个Inner对象的引用。 代码实现如下： public class Outer { Outer() { System.out.prin...
java 程序设计题库
热门推荐
cat marshal的博客
06-18 3万+
答题要求：单选题，每题只有一个正确答案，选择正确给分，不正确不给分。 1、 下面（ A ）数据类型可用于main()方法中传递的参数 A、String B、Integer C、Boolean D、Variant 2、以下的选项中能正确表示Java语言中的一个整型常量的是（ B ） A、12． B、-20 C、1,000 D、4 5 6 3、下列的变量定义...
为什么需要public static void main(String[] args)这个方法？
牧野飞鸿的博客
02-02 3890
1. 为什么需要public static void main(String[] args)这个方法？ Java程序的入口方法，JVM在运行程序时首先找main()方法； public是权限修饰符，表明任何类或对象都可以访问这个方法； static表明main()方法是一个静态方法，即方法中的代码是存储在静态存储区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过...
JAVA学习笔记
丰旭的博客
01-29 1509
第一章 IDEA基本配置和快捷键 IDEA快捷键 快捷键 功能 ctrl+Y 删除当前行 ctrl+D 复制当前行 Alt+Enter 导入包自动修正代码 Ctrl+Alt+L 格式化代码 Ctrl+/ 单行注释，再按取消 ctrl+shift+/ 选中代码注释，再按取消 Alt+Ins 自动生成代码：如toString,set,get等方法 Alt+S...
Java面试题
weixin_49237268的博客
05-07 1890
Java基础 1、什么是面向对象，有哪些特征？结合代码说明 面向对象就是不用在意方法的内部实现 只用关注方法的实现 特征：封装：属性私有化 方法公开化 ​ 继承：子类可以继承父类非私有的方法和属性 并可以对其进行重写 ​ 多态：父类做引用子类实例化 2、Java基本数据类型有哪些，分别占用多少内存，对应封装类是哪些 类型|默认值|包装类|大小 byte (byte)0 Byte 1byte short (short)0 Short 2byte int 0 Integer
经典笔试题-Java基础篇
逍遥云恋
02-10 634
1、面向对象的特征有哪些方面? 【基础】 答：面向对象的特征主要有以下几个方面： 1)抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象,二是数据抽象。 2)继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新...
java设计一个people类_求Java程序。。。（2）设计一个People接口，其中有eat( )、sleep（）、run（）、study（）等方法...
weixin_39533307的博客
02-27 814
共回答了15个问题采纳率：93.3%2)public interface People{public void eat();public void sleep();public void run();public void study();}class Man implements People{public void eat(){System.out.println("Man eat !");}...
牛客易错题记录
Hello什么来着？
12-22 655
1.下列选项中属于面向对象设计方法主要特征的是（ ）。 正确答案: A 你的答案: C (错误) 继承 自顶向下 模块化 逐步求精 解析：封装、继承、多态 2.对于子类的构造函数说明，下列叙述中错误的是（ ）。 正确答案: A 你的答案: C (错误) 子类可以继承父类的构造函数。 子类中调用父类构造函数不可以直接书写父类构造函数，而应该用super();。 用new创建子类的对象时...
java题1
weixin_42175570的博客
10-05 1万+
  1、面向对象的特征有哪些方面      ①抽象：     抽象是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。     ②继承：     继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类...
C++面向对象编程基础与实践
而C++是在C的基础上为了支持面向对象编程而扩展的，它引入了类、对象和新的语法结构，但相比C#和Java，C++的面向对象特性可能不够纯粹。C++同时支持面向过程和面向对象编程，意味着这两种方法将在一段时间内共存。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值