Java基础之面向对象

面向对象 & 面向过程

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍然需要面向过程的思路去处理。

面向对象

面向对象编程（Object-Oriented Programming,OOP）
本质：以类的方式组织代码，以对象的组织（封装）数据
三大特性：封装、继承、多态
从认识论：先有对象后有类。
对象是具体的事物。类是抽象的，是对对象的抽象。
从代码运行：先有类后有对象。
类是对象的模板。

值传递 & 引用传递

//值传递
public class Demo1 {
	//break :跳出switch、结束循环
	//return ：结束方法，返回一个结果
	
	//静态方法 static
	//非静态方法 实例化这个类 new
	
	public static void main(String[] args) {
		int a = 1;
		System.out.println(a);//1
		change(a);
		System.out.println(a);//1
	}
	//返回值为空
	public static void change(int a){
		a = 10;
	}

}

//引用传递 对象
public class Demo2 {

	public static void main(String[] args) {
		Person person = new Person();
		System.out.println(person.name);//null
		change(person);
		System.out.println(person.name);//123

	}
	public static void change(Person person){
		person.name = "123";
	}
}
//定义一个Person类，有一个属性：name
class Person{
	String name;//null
}

创建类与对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

类中的构造器也叫构造方法，是在进行创建对象的时候必须调用的。

特点：

• 必须和类的名字相同
• 必须没有返回类型，也不能写void

作用：

• 使用new关键字，本质在调用构造器
• 初始化对象的值

注意点：定义有参构造后，若想使用无参构造，须显示定义无参构造

//一个项目应该只有一个main方法
public class Application {

	public static void main(String[] args) {
		//类：抽象的，实例化
		//类实例化后会返回一个自己的对象！
		//student对象就是一个Student类的具体实例 ！
		Student student = new Student();
		student.name = "小明";
		student.age = 60;
				
		System.out.println(student.name);
		System.out.println(student.age);

	}

}

//学生类
public class Student {
	//属性：字段
	String name;//null
	int age;//0
	//方法
	public void study() {
		System.out.println(this.name);
	}


}

public class Person {
	//一个类即使啥也不写，也会存在一个方法
	
	String name;
	
	//alt+insert(IDEA)
	
	//1.使用new关键字，本质在调用构造器
	//2.用来初始化值
	//显示定义
	//无参构造
	public Person(){
	}
	
	//有参构造：一旦定义，无参构造必须显示定义
	public Person(String name){
		this.name = name;
	}

}

创建对象内存分析

public class Application {
	public static void main(String[] args) {
		Pet dog = new Pet();
		Pet cat = new Pet();
		dog.name = "旺财";
		dog.age = 5;
		dog.shout();
		
		System.out.println(dog.name);
		System.out.println(dog.age);
	}
}

public class Pet {
	String name;
	int age;
	
	//无参构造
	
	public void shout() {
		System.out.println("叫了一声");
	}
}

封装

“高内聚，低耦合”（该露的露，该藏的藏）

属性私有，get/set

意义：

1. 提高程序安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加系统可维护性

//类   private 私有
public class Student1 {
	//属性私有
	private String name;
	private int id;
	private char sex;
	//get、set方法
	//IDEA:alt+insert
	//Eclipse:alt+shift+s
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
}

继承

本质：对某一批类的抽象

• extends：扩展。子类是父类的扩展。
• Java只支持单继承，不允许多重继承。
• Object类是所有Java类的根父类。
  

supper

1. supper调用父类的构造方法，必须在构造方法第一行
2. supper只能出现子类的方法或构造方法中
3. supper和this不能同时调用构造方法

比较	this	supper
代表对象	本身调用者	父类对象的应用
前提	没有继承也可	只能在继承条件下
构造方法	this();本类构造	supper();父类构造

//Object类是所有Java类的根父类。
public class Person {
	public Person() {
		System.out.println("Person无参");
	}
	protected String name = "13";
	
	public void print() {
		System.out.println("person");
	}
	//私有的东西无法被继承
	private void print2() {
		System.out.println("person2");
	}
}

//学生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
	public Student() {
		//隐藏代码：调用了父类的无参构造
		super();//调用父类构造器，必须要在子类构造器的第一行
		System.out.println("Student无参");
	}
	private String name = "567";
	
	public void print() {
		System.out.println("student");
	}
	public void test(String name) {
		System.out.println(name);
		System.out.println(this.name);
		System.out.println(super.name);	
	}
	public void test2() {
		print();
		this.print();
		super.print();
	}
}

public class Application {
	public static void main(String[] args) {
		Student student = new Student();
		student.test("789");
		student.test2();
	}
}

重写

需要有继承关系，子类重写父类的方法。

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大 public>protected>default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大 ClassNotFoundException->Exception

为什么要重写？父类的功能，子类不一定需要，或不一定满足。

//重写是方法的重写，和属性无关
public class B {
	public void test() {
		System.out.println("B>test");
	}
}

public class A extends B{
	//IDEA:alt+insert
	//Eclipse:alt+shift+s
	@Override//注解：重写
	public void test() {
		System.out.println("A>test");
	}	
}

public class Application {
	public static void main(String[] args) {
		//静态方法和非静态方法区别很大
		//静态方法（static）:方法的调用只和左边定义的数据类型有关
		//非静态：重写
		A a = new A();
		a.test();
		//父类的引用指向了子类
		B b = new A();//子类重写了父类的方法
		b.test();
	}
}

多态

注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常！ClassCastException！
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象

不能重写：

• static方法，属于类，不属于实例
• final 常量
• private 方法

public class Person {
	public void run() {
		System.out.println("run");
	}
}

public class Student extends Person{

	@Override
	public void run() {
		System.out.println("son");
	}
	public void eat() {
		System.out.println("eat");
	}
	
}

public class Application {
	public static void main(String[] args) {
		//一个对象的实际类型是确定的
		//new Student();
		//new Person();
		
		//可以指向的 引用类型就不确定了：父类的引用指向子类
		//Student能调用的方法都是自己的或继承父类的
		Student s1 = new Student();
		//Person父类型，可以指向子类，但不能调用子类独有的方法
		Person s2 = new Student();
		Object s3 = new Student();
		//对象执行哪些方法，主要看对象左边的类型，和右边关系不大
		s2.run();//子类重写了父类的方法，执行子类的方法
		((Student) s2).eat();//类型转换
	}
}

instanceof

public class Application {
	public static void main(String[] args) {
		//x instanceof y
		Object s1 = new Student();
		
		System.out.println(s1 instanceof Student);//true
		System.out.println(s1 instanceof Person);//true
		System.out.println(s1 instanceof Object);//true
		System.out.println(s1 instanceof String);//false
		
		Person s2 = new Student();
		
		System.out.println(s2 instanceof Student);//true
		System.out.println(s2 instanceof Person);//true
		System.out.println(s2 instanceof Object);//true
		
		Student s3 = new Student();
		
		System.out.println(s2 instanceof Student);//true
		System.out.println(s2 instanceof Person);//true
		System.out.println(s2 instanceof Object);//true
	}
}

public class Application {
	public static void main(String[] args) {
		//类型之间的转化：父  子
		//高   低
		Person s2 = new Student();
		((Student) s2).eat();//类型转换
		//子类转换为父类，可能丢失自己本来的一些方法
	}
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，强制转换
4.方便方法的调用，减少重复的代码
 */

static

//静态导入包
import static java.lang.Math.random;
//static
public class Student {
	
	//1.只执行一次
	static{
		//静态代码块
	}
	
	//2.赋初值
	{
		//匿名代码块
	}
	
	//3.
	public Student(){
		//构造方法
	}
	
	private static int age;//静态变量
	private double score;//非静态变量
	
	public void run() {	
	}
	
	public static void go() {
		
	}
	
	public static void main(String[] args) {
		Student s1 = new Student();
		go();
		Student.go();
		s1.go();
		System.out.println(Student.age);
		System.out.println(s1.age);
		System.out.println(s1.score);
		
		System.out.println(random());
	}

	
	
}

抽象类

• 不能new这个抽象类，只能靠子类去实现它；约束！
• 抽象类可以写普通的方法
• 抽象方法必须在抽象类中

//抽象类 类：单继承    接口：多继承
public abstract class Student {
	//抽象方法，只有方法名，没有方法的实现
	public abstract void doSomething();
	
}

接口

约束和实现分离 接口的本质是契约
接口的特点：

• 用interface来定义。
• 接口中的所有成员变量都默认是由public static final修饰的。
• 接口中的所有方法都默认是由public abstract修饰的。
• 接口没有构造器。
• 接口采用多层继承机制

//接口都需有实现类
public interface UserService {
	//常量 public static final
	int AGE = 99;
	//接口中所有定义其实都是抽象的 public abstract
	void add(String name);
	void delete(String name);
	void update(String name);
	void query(String name);
}

//实现接口的类，就要重写接口的方法
//多继承 
public class UserServiceIml implements UserService{

	@Override
	public void add(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void delete(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void update(String name) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void query(String name) {
		// TODO Auto-generated method stub
		
	}
}

内部类

public class Outer {
	private int id=10;
	public void out() {
		System.out.println("这是外部类的方法");
	}
	public class Inner{
		public void in() {
			System.out.println("这是一个内部类的方法");
		}
		//获得外部类的私有属性
		public void getID() {
			System.out.println(id);
		}		 
	}
	public static class Inner2{
		public void in() {
			System.out.println("这是一个静态内部类的方法");
		}	 
	}
	//局部内部类
	public void method() {
		class Inner{
			
		}
	}
}
//一个Java类中可以有多个class类，但只能有一个public class
class A{
	
}

public class Application {

	public static void main(String[] args) {
		//
		Outer outer = new Outer();
		//通过外部类实例化内部类
		Outer.Inner inner = outer.new Inner();
		//没有名字初始化类，不用将实例保存到变量中
		new Outer().method();
	}

}

学习视频：狂神说Java