Java学习笔记——面向对象编程（核心）

- [1 类和对象](https://cloud.tencent.com/developer)
    - [1.1 类成员](https://cloud.tencent.com/developer)
    - [1.2 类的创建和使用](https://cloud.tencent.com/developer)
    - [1.3 权限修饰符](https://cloud.tencent.com/developer)
    - [1.4 小知识](https://cloud.tencent.com/developer)
- [2 面向对象三大特征](https://cloud.tencent.com/developer)
    - [2.1 封装 (Encapsulation)](https://cloud.tencent.com/developer)
    - [2.2 继承 (Inheritance)](https://cloud.tencent.com/developer)
        - [2.2.1 定义](https://cloud.tencent.com/developer)
        - [2.2.2 作用](https://cloud.tencent.com/developer)
        - [2.2.3 注意](https://cloud.tencent.com/developer)
        - [2.2.4 方法的重写(override)](https://cloud.tencent.com/developer)
    - [2.3 多态 (Polymorphism)](https://cloud.tencent.com/developer)
- [3 其他关键字](https://cloud.tencent.com/developer)
    - [this](https://cloud.tencent.com/developer)
    - [super](https://cloud.tencent.com/developer)
    - [package](https://cloud.tencent.com/developer)
    - [import](https://cloud.tencent.com/developer)
    - [static](https://cloud.tencent.com/developer)
        - [类变量(class Variable)](https://cloud.tencent.com/developer)
        - [类方法(class Method)](https://cloud.tencent.com/developer)
    - [final](https://cloud.tencent.com/developer)
- [4 Object类](https://cloud.tencent.com/developer)
    - [4.1 主要方法](https://cloud.tencent.com/developer)
- [5 包装类(Wrapper)](https://cloud.tencent.com/developer)
    - [5.1 装箱](https://cloud.tencent.com/developer)
    - [5.2 拆箱](https://cloud.tencent.com/developer)
    - [5.3 字符串和基本数据类型之间的转换](https://cloud.tencent.com/developer)
- [6 抽象类 (abstract class)](https://cloud.tencent.com/developer)
- [7 接口 (interface)](https://cloud.tencent.com/developer)

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

//创建静态内部类的对象：可以直接通过外部类调用静态内部类的构造器
Person.Dog d = new Person.Dog();
//创建非静态的内部类的对象：必须先创建外部类的对象，通过外部类的对象调用内部类的构造器
Person p = new Person();
Person.Bird b = p.new Bird();

public class A{
       private int s = 111;
       public class B {
		private int s = 222;
		public void mb(int s) {
	        System.out.println(s);              // 局部变量s
	        System.out.println(this.s);      // 内部类对象的属性s
	        System.out.println(A.this.s);   // 外层类对象属性s
        }
	}
}

public class TestOOP {
	public static void main(String[] args) {
		// 2.  创建类的实例（对象）
		Animal nAnimal = new Animal("猴子", 1);
		// 调用类的属性或方法
		nAnimal.eat();
		System.out.println(nAnimal.getName());
	}
}

// 1. 设计并定义类
class Animal{
	// 属性
	private String name;
	public int age;
	
	// 构造器
	public Animal() {}
	public Animal(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	// 方法
	public void eat() {
		System.out.println(name + "进食");
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
	// 代码块
	{
		System.out.println("??");
	}
}

public class Person {
      public String name;
      public int age;
      public Date birthDate;
      public String getInfo() {...}
}

public class Student extends Person{
      public String school;
}

class Subclass extends Superclass{ }

package mytest;

public class A{
	private void privateFunc() {
		System.out.println("A privateFunc");
	}
	
	void defaultFunc() {
		System.out.println("A defaultFunc");
	}
	
	protected void protectedFunc() {
		System.out.println("A protectedFunc");
	}
	
	public void publicFunc() {
		System.out.println("A publicFunc");
	}
}

package mytest;

public class B extends A{
	// 不是重写，而是定义了另外一个函数，重写的前提是有访问权限
	private void privateFunc() {
		System.out.println("B privateFunc");
	}
	
	// 重写
	void defaultFunc() {
		System.out.println("B defaultFunc");
	}
	
	// 重写
	protected void protectedFunc() {
		System.out.println("B protectedFunc");
	}
	
	// 重写
	public void publicFunc() {
		System.out.println("B publicFunc");
	}
}

package mytest;

public class Test {
	public static void main(String[] args) {
		A a = new B();
		B b = new B();
//		a.privateFunc(); // 只能在类内部调用
		a.defaultFunc();
		a.protectedFunc();
		a.publicFunc();
		
//		b.privateFunc(); // 只能在类内部调用
		b.defaultFunc();
		b.protectedFunc();
		b.publicFunc();
	}
}

B defaultFunc
B protectedFunc
B publicFunc
B defaultFunc
B protectedFunc
B publicFunc

// B继承A
A a = new B(); // 向上转型
a.defaultFunc(); // 虚拟方法调用(Virtual Method Invocation)
//a.bfunc(); // 无法调用子类中添加的方法
((B)a).bFunc(); // 强制类型转换（向下转型）

package 顶层包名.子包名

import  包名[.子包名…]. <类名 |*>

A a1 = new B();
a1.staticFunc(); // A staticFunc
((B)a1).staticFunc(); // B staticFunc

Boolean boolean1 = true;
boolean b = boolean1.booleanValue();

class SubClass implements InterfaceA{ }

public interface Runner {
	int ID = 1;
	void start();
	public void run();
	void stop();
}

Runner r = new Runner(){
	// 实现接口的所有方法
}