面向对象编程 JavaSE （私有学习版）

面向对象（上）

1.数组

2.构造器

或者叫构造方法。

（1）定义

构造器是类中必不可少的部分，创建类的时候需要使用他。

（2）使用

假设存在一个主类名字为Main

现定义一个Person类，其中一定要会有构造器（当没有创建构造器时，默认一个无参构造器）

构造器中也可以调用方法

class Person{
	int age;     //属性
    String name;  //属性
    
    public Person(){
        
    }				//Person() ：构造器
   
}
    

（3）构造器的使用

public class Main{
    public static void main(){
        Person test = new Person(1,1);  //其中1,1分别是对下面构造器中Person定义的m,n进行赋值。赋值后然后运行构造器里面的程序。 
    }
}



class Person{
	int age;     //属性
    String name;  //属性
    
    public Person(int m,int n){
        
    }				//Person() ：构造器
   
}
    

3.this关键字

（1） 使用

在创建的方法那一栏中，创建了形参命名为age方便记忆，但是和属性age重名，为了在方法内调用属性，采用this.age来充当属性中的age。

如果方法的形参和类的属性同名时，必须用this.来表明此变量时属性。其他情况下可以选择省略

class Person{
	private int age;     //属性
       
    public Person(){
        
    }				//Person() ：构造器
   
    public void setName(int age){
        this.age = age;
    }
    public int getName(){
        return this.name;
    }
}

    

下面为主类

public class Main{												
	public static void main(){									
	Person test =new Person();
	test.setAge(10); 
	System.out.println(test.getName);
}

输出结果
    10

（2）用途

用来修饰和调用属性方法和构造器

在Person类中有如下构造器

public Person(){
	this.getAge();  //在构造器中调用此方法
}

public Person(String name){
    this(); 			//调用空参构造器，直接执行上面那个空参构造器的程序
    this.name = name;   //执行自己构造器的程序
}

完整代码如下

public class Main {
	public static void main(String[] args) {
		Person test =new Person("张三");
		System.out.println(test.getName());
	}
	
	
}

class Person{
	int age;
	String name;
	
	public Person() {
		this.getName();
	}
	public Person(String name) {
		this();
		this.name = name;          //在这个构造器中调用上面的空参构造器，结果在主类中执行的食用调用下面的一个构造器，就可以直接执行上面的语句。 
    
	}
	public void setName(String name) {
		this.name = name;
		
	}
	public String getName() {
		return name;
	}
}

4.package关键字

（1）作用

为了更好的实现项目的管理，提供包的概念

（2）特征

包属于标识符，遵循标识符的命名规则xxxyyyzzz，全都是小写。+

（3）关于.

每 . 一次就代表一层文件目录

（4）补充

1.同一个包下，不能命名同名的接口、类

2.不同的报下，可以命名同名的接口、类

（5）jdk中主要包

---

1.java.lang：包含核心类，String、Math、Integer、System、thread

2.java.net：包含执行与网络相关的操作的类和接口

3.java.io：包含能提供多种输入/输出功能的类

4.java.util：包含一些实用工具类，比如定义系统特性、接口的集合框架类、使用与日期相关的函数。

5.java。txt：包含了一些java格式化相关的类

6.java.sql：包含了java进行jdbc数据库编程的相关类/接口

---

7.java.awt：包含了构成抽象窗口工具集（abstact、window、toolkits的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。）B/S 、C/S

---

（6）包的导入

放在需要用到的语句 shift+ctrl+o

或者手动import

5.MVC设计模式

MVC是常用的设计模式之一，把整个程序分为视图模型层、控制器层、数据模型层，这种将程序输入输出、数据处理和数据的展开分离开来的设计模式，使程序结构变得灵活清晰，同时也描述了程序各个对象的通信方式，降低了程序的耦合性。

6.import关键字的使用

（1）含义：导入

在源文件中显式的使用import结构导入指定包下的类，接口。

在选中对应类或接口按shift+ ctrl+o

例如Person person =new Person();

（2）使用

1.可以使用“xxx.*”的方式，表示可以导入xxx包下的所有结构

2.如果需要导入多个结构，并列写出即可。

3.如果使用的接口是java.lang包或者本包下定义的，则可以省略import结构

4.如果源文件中，使用了不同包下同名的类，则必须至少有一个类需要以全类名的方式显示。

5.import static：导入指定或接口中的静态结构。

面向对象（中）

1.继承性

（1）好处

1.减少了代码的冗余，提高了代码的复用性。

2.便于功能的扩展。

3.为了后多态性的使用，提供了前提。

（2）格式

class A extendx B{}

子类、派生subclass

父类、超类、基类

superclass

体现

• 一旦子类A继承父类B之后，子类A就获取到父类B中声明的所有的属性、方法。父类中声明为private属性和方法，子类继承父类以后，仍然认为获取了父类中似有的结构。只是因为封装性的影响，子类不能直接调用父类的结构。

• 子类继承父类以后，仍然还可以定义子类自己的属性或方法，实现功能的拓展。因此子类和父类不同于集合的关系。

注意

• 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.object类

• 所有的java类（除java.lang.object类）都直接或间接继承java.lang.object

2.方法的重写

（1）定义

• 在子类中可以根据需要对从父类中继承来的方法进行改造，也成为方法的重置或覆盖。

• 在程序执行时，子类的方法将覆盖父类的方法

（2）要求

• 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

• 子类重写的方法的返回值类型不能大于 父类被重写的方法的返回值类型

• 子类重写的方法使用的权限不能小于父类重写的方法的访问权限

  子类不能重写父类中声明为private的方法

• 子类方法跑出的异常不能大于父类被重写方法的异常

子类和父类中同名同参数的方法必须同时声明非static的，或者同时声明为static的。因为static方法时属于类的，子类无法覆盖父类的方法。

（3）规范

方法的声明：

权限修饰符 返回值类型 方法名（形参列表）{
				方法体

}
//其中方法名和形参列表要和父类一模一样，才能定位到需要重写的方法。

3.四种权限修饰符

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
缺省	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

• 对于class的权限修饰符只可以用public和缺省
• public类可以在任意地方被使用
• 缺省类只可以被同一个包内部的类访问

4.super关键字

(1)作用

当父类方法被重写后，重写之前的方法用super关键字可以来实现调用

还可以用来调用构造器，属性

(2)使用

1.父类和子类中出现了同名的属性，例如命名为id

当子类调用id的时候,用this.id则调用子类中的id值

当子类调用id的使用,用super.id则调用父类中的id值

2.super调用构造器

public class Students extends Students2;
public Person(){
	super(形参列表);

}
//这种情况下，Person构造器调用的就是Studensts2`父类`的构造器。

注意

• super的使用，必须声明在子类构造器的首行
• 在类的构造器中，this(形参列表)和super（形参列表）只能二选一，不能同时使用。
• 在构造器的首行，没有显式的声明this（形态列表）或super（形态列表），则默认调用的是父类中的构造器。此时默认有一个没有显式的super（形参列表）

5.多态性

（1）定义（对象的多态性）

父类的引用指向子类的对象

Person p1 = new Person();


Person p2 = new Person();


Penson p3 = new Person();

使用（虚拟方法调用）

• 调用子父类同名同参数的方法的时候，调用的是子类中重写的方法。

• 多态性不适用于属性。

使用前提

• 类的继承关系
• 方法的重写

Person test = new Person();
test.man(new Woman());//此时调用的是Woman方法中的语句，此为多态的使用
	




//man和Woman为两个不同的类 上面为Person类
public void man(){
	省略    
}

public void Woman(){
    省略
}

• 向上转型就是多态。

(2)向下转型

了对象的多态性之后，内存中实际上加载了子类所特有的属性和方法，但是由于变量声明为父类类型，导致编译时只能调用父类的属性和方法，子类特有的属性和方法不能使用。 于是就要使用强制类型转换

假如有Man类,现在在测试类中写如下语句

假如getName是子类中特有的属性和方法

Person p2 = new Man();//多态性的体现
p2.eat;//调用的是子类中重写的eat方法

//向下转型
Man m1 = (Man)p2;//Man了m1  强制将p2转给m1，就必须用这样的强制转型服。转型之后，才可以调用子类中特有的属性和方法
m1.getName;

（3）instanceof关键字

使用

• a instanceof A：判断对象a是否是类A的实例，如果是则返回true，如果不是则返回false

假设存在Person,Man ,Woman 3个类

Person p2 = new Man(); 这里可以看出p2是Man的实例

if(p2 insetanceof Woman){
    Woman w1 = (Woman)p2;
    w1.getAge();
    System.out.println("Woman");
}
//因为p2是Man的实例 所以输出false，输出结果为空。

if(p2 insetanceof Man){
    Man m2 = (Man)p2;
    w1.getAge();
    System.out.println("Man");
}
//p2是Man的实例，所以输出false，输出结果为Man。

• instanceof的使用是为了避免向下转型是出现ClassCastException的异常。比如Man强制转型成Woman就会出现ClassCastException的异常

6.Object类

(1)java.lang.Object类

• Object类是所有Java类的根父类

• 如果在类的声明中未使用extends指明其父类，则默认父类为java.lang.Object

• (2)Object类的功能（属性和方法）都有通用性

（2）Object类的主要结构

7. ==和equals的区别（面试题）

1.==运算符

• 可以使用在基本数据类型和引用数据类型中

• 如果比较的是基本数据类型变量，比较两个变量保存的数据是否相等（不一定数据类型要相等）

• 如果比较的是引用数据类型，则比较地址值是否相同。

2.equals（）方法

• 是一个方法，而非运算符

• 只能适用于引用数据类型

• Object类中equals（）的定义

  public boolean equals(Object obj){

  return(this == obj);

  }

  • equals方法和==都是比较的地址值。

System.out.println(cust1.equals(cust2));

8.包装类

基本数据类型	包装类
byte	Byte
short	Short
int	integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

基本数据类型转化为包装类

public void test1 () {
        int num1 = 10;
//        System.out.println(in1.toString());//错误
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());
    }
//将num1转化为包装类之后，就可以使用toString()输出了

in1.toString()和in1的作用是一样的，但是可以对toString()方法进行重写。

包装类转化为基本数据类型

• 调用包装类的xxxValue()

Integer in1 = new Interger(12);//此时in1为包装类
int i1 = in1.intValue();//i1为in1转化为的int型，于是可以进行加减乘除运算。

自动装箱与自动拆箱

• 自动装箱

int num2 = 10;
Integer in1 =num2;
//看起来像是int型赋值给了一个包装类，其实是进行了自动装箱

• 自动拆箱

int num2 = in1;
//看起来像是直接把一个包装类赋值给了一个int类型

• 包装类、基本数据类型和String类型的转换

//方法1
int num 1 = 10;
String str1 = num1+"";

float f1 = 12.3f
String str2 = String.valueOf(f1);
//调用String的valueOF(XXX)

9.static关键字

有些时候希望无论是否产生了对象，或者无论产生了多少对象的情况下，某些特定的数据在内存空间中只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的

• static修饰的变量是被共享的

使用

• static可以用来修饰属性、方法、代码块和内部类

public class StaticTest{
	public static void main(String []args){
		Chinese c1 =new Chinese();
		c1.name ="姚明";
		c1.age = 40;
		
		Chinese c2 =new Chinese();
		c2.name="马龙";
		c2.age=30;
	}
}

class Chinese(){
	String name;
	int age
}

• 实例变量：创建了类的多个对象，每个对象都独立拥有一套类的非静态属性，当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
• 静态变量：我们创建了类的多个对象，多个对象共享了同一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

static修饰属性的说明

• 静态变量随着类的加载而加载。可以通过“类.静态变量”的方式调用。
• 静态变量的加载要早于对象的创建。
• 由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。

static修饰方法：静态方法

• 随着类的加载而加载，可以通过“类.静态方法”的方式进行调用

开发中，怎么确定是否要声明static属性

• 所有类都共有的，例如一个银行项目中的利率，和存款最小余额可以定义为static，像账户账号和密码之类的就不能定义为static

10.单例设计模式（Singleton）

含义

• 采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

饿汉式设计模式

class Bank{
	private Bank(){
	
	}
	private static Bank instance = new Bank();
	public static Bank getInstance(){
		return instance
	}

}

懒汉式设计模式

class Order(
	//1,私有化类的构造器
	private Order(){
	
	}
	//2.声明当前类对象，没有初始化
	private static Order instance = null;
	
	//3.声明public static的返回当前类的方法
	public static Order getInstance(){
		if(instance == null){
			instance = new Order(); 
			
			//如果instance==null，说明还没有创建对象，则需要创建对象，否则返回instance的值
		}
		return instance;
	}
	

)

区别

• 饿汉式在类里面先造好一个static的对象 ，然后再有一个返回类的方法。

• 懒汉式中创建对象的过程在方法里面，声明时候要用方法的时候就创建类。

区别

• 饿汉式：坏处：对象加载时间过长

  ​ 好处：饿汉式是线程安全的

• 懒汉式：好处：延长对象的创建

  ​ 坏处:目前的写法，线程不安全

11.代码块

class Person(){
//属性
//构造器
//代码块
{

}
//方法


}

代码块的作用

用来初始化类、对象，可以在括号前面用static修饰，不能用其他修饰，修饰则为静态代码块，否则为非静态代码块

• 静态代码块

  static{
  
  }
  

• 非静态代码块

{

}

静态代码块

• 内部可以有输出语句

  在主方法中 String desc = Person.desc

此语句可以让静态方法和静态属性都执行，也可以执行静态代码块中的语句

• 随着类的加载而加载
• 作用：初始化类的信息
• 如果一个类中定义了多个静态代码块，则按照声明的先后顺序来执行。
• 静态代码块的执行要优先于非静态代码块。因为静态代码块是在随着类的加载而加载执行，而非静态代码块需要在类中创建对象后执行。

非静态代码块

• 随着对象的创建而加载

  Person p1 =new Person();在主方法中创建对象，就可以执行代码块中的于

• 每创建一次对象，就执行一次非静态代码块

• 作用：可以在创建对象时，对对象的属性进行初始化。

对属性可以赋值的位置

• 默认初始化
• 显式初始化
• 构造器中初始化
• 有了对象以后，通过“对象.属性”或“对象.方法”的方式，进行赋值
• 在代码块中赋值

执行的顺序：1-2/5-3-4，2和5谁放前面，先执行谁

12.final关键字

final：最终的

可以用来修饰的结构：类、方法、变量

• final用来修饰一个类:此类就不能被其他类继承

  • 比如String类、System类、StringBuffer类

  final class FinalA{
  
  }
  

  class B extends String{
  
  }
  //会报错，因为String类也是一个final类，不能被继承.
  

• final修饰一个方法：此方法就不能被重写

  • 比如Object类中的getClass（） 不能被重写

  final AA{
  	public final void show(){
  	
  	}//此方法就不能在子类中重写
  }                                         
  

• final修饰变量：此时的变量就成为一个常量了

  • final修饰属性，可以考虑赋值的位置有：显式初始化，代码块中初始化，构造器中初始化

  public class FinalTest{
  	final int width = 10;
  	public void dowidth(){
  		width=20;//报错。因为width属性是一个常量
  	}
  }
  

• final修饰局部变量

  • 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体中使用此形参，但不能进行重新赋值。

static final

• 用来修饰属性：全局变量

13.抽象类和抽象方法

• 类的设计应该保证父类和子类能够共享特征。有时将一个父类设计的非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

abstract修饰类：抽象类

abstract class Person{
	//内容
}

• 当类抽象后，该类就不能造对象。只能用他的子类造对象。
• 抽象类中一定有构造器
• 开发中，都会提供抽象类的子类，让子类对象实例化来完成相关的操作

abstract类修饰方法

public abstract void eat();

• 抽象方法只有方法的声明，没有方法体。

• 因为抽象方法没有方法体，因此不能被调用，所以包含该方法的类不能被调用，所以包含抽象方法的类一定为抽象类，但是抽象类中可以没有抽象方法。

• 若子类重写了父类所有的抽象方法后，此子类方可实例化。

抽象类匿名子类对象

Work worker =new Worker();
method(worker);
//这种为非匿名的类 非匿名的对象

method(new Worker);
//这种为非匿名的类 匿名的对象，因为输入了一个new的对象给形参，没有确定该new的对象的名称

Person P = new Person(){
	public void eat(){

	}
	public void breath(){

	}
};
//这样写就叫创建了一个匿名类的对象

模板方法的设计模式

• 在软件开发中实现一个算法时，整体步骤很简单、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现，这就是一种模板模式。

14. 接口

• Java不支持多重继承，有了接口，就可以实现多重继承。

1.接口的使用

• 接口使用interface来定义

  interface Flyable{
  
  }
  //定义了一个接口
  

  说明

• JAVA中，接口和类是并列的两个结构

• 如何定义接口：定义接口中的成员

  • JDK7以前，只能定义全局常量和抽象方法

    • 全局常量：public static final的,但是书写时可以省略
    • 抽象方法：public abstract

  • JDK8，除了定义全局变量和抽象方法之外，还可以定义静态方法，默认方法

interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;//宇宙第一速度
	int MAX_SPEED =7900//省略public static final
	
	
	//抽象方法
	public abstract void fly();
	void stop;//省略了public abstract
}

• 接口中不能定义构造器，意味着接口不可以实例化
• Java开发中，接口通过让类去实现（implements）的方式来使用

class Plane implements Flyable{
	public void fly();
		System.out.println("通过引擎飞");
	public void stop(){
		sysout;
	}
	//已经覆盖了接口中的所有抽象方法，所以现在可以写输出语句
}

如果实现类覆盖了接口中的所有方法，则此实现类就可以实例化

如果实现类没有覆盖接口中的所有抽象方法，则此实现类就仍为一个抽象类

2.实现多个接口

• 格式：class AA extends BB implements CC,DD,EE{

  }

3.接口之间可以多继承

interface AA{
	public static final void XXXX;
}
interface BB{

}

interface CC extends AA,BB{

}//实现了CC继承AA,BB

4.说明

• 接口的具体使用，体现了多态性
• 接口，实际上可以看做是一种规范

5.匿名实现类

Flash flash = new Flash();
	com.transferData(flash);
	//创建了接口的非匿名实现类的非匿名对象
	
	
	com.transferData(new Printer());
	//创建了接口的非匿名实现类的匿名对象

	USB phone = new USB(){
		public void start(){
		
		}
		public void stop(){
		
		}
	}; 
	//创建了接口的匿名实现类的非匿名对象
	
	
	
	com.transferData(new USB){
		public void start(){
		
		}
		public void stop(){
		
		}
	}
	//创建了接口的匿名实现类的匿名对象

接口的应用（了解）

• 代理模式：Java开发中较多的一种设计模式，代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

• 工厂模式：实现了创建者和调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的

15.内部类

• 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

• Inner class 一般用在定义在它的类或语句块之内在内部引用它时必须给出完整的名称。

  • Inner class的名字不能与包含它的外部类名字相同

• 内部类的分类：局部内部类，成员内部类

class void method(){
	class AA{
	
	}
}//局部内部类


class Person{
//静态成员内部类
	static class Dog{
	
	}
//非静态成员内部类
	class Bird{
	
}

成员内部类

• 一方面，作为外部类的成员
  • 调用外部类的结构
  • 可以被static修饰
  • 可以被4种不同的权限修饰
• 另一方面，作为一个类
  • 类内可以定义属性、方法、构造器等
  • 可以用final修饰，表示不能被继承。
  • 可以本abstract修饰，表示不能被实例化

问题

• 如何实例化成员内部类的对象

  •   public class InnerClassTest{
      	public static void main(String[]args){
      		Person.Dog dog = new Person.Dog();
      		dog.show();
      		}//静态的成员内部类
      		
      		Person p = new Perosn();
              Person.Bird bird = p.new Bird();
              //非静态的成员内部类
      		
      		
      		
      }
    

• 如何在成员内部类中区分调用外部类的结构

• 开发中，局部内部类的使用