继承：为了实现复用；继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类 都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
//在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
//使用 implements 关键字可以变相的使java具有多继承的特性，
// 使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
封装：为了隐藏实现细节，对外只暴露接口，提供公共的访问方式；
多态：满足继承关系，父类引用变量指向子类对象，子类重写父类方法；消除类型之间的耦合关系。
类：一种抽象的数据类型；具备某些共同特征的实体的集合；是对所具有的相同特征实体的抽象。
定义了私有变量和方法。
类--【实例化】--对象；所以对象又称为实例。对象--【抽象】--类；
类描述的是对象的共同特征，比如身高，必须体现创建对象，通过对象去访问这个特征。
一个类主要描述的是状态（身高、体重、颜色，一个类的属性）和动作（吃，跳舞，一个类的方法）。
private:只能在当前类内部访问 protected:能在当前类和子类，同一个包中访问； public:能在当前类/子类/其他package中访问。
面向接口编程：开发功能的时候先定义接口，接口中定义约定好的功能方法声明，通过实现该接口
进行功能实现。
angular css文件webpack打包原理：每一个component的HTML文件的每一个标签，都会被唯一的属性所标识，在渲染的时候，会通过
类选择器（或其他选择器）+ 属性标识被选择添加相应的样式。
angular 属性装饰器如@Input，
@Compont({
html;
css;
})
class UserComponent{
@Input() username;//UserComponent.prototype.ng....=xxxx-[username]
ngOnInit(){
}
}
//parent
<app-user [username]="'xiaodong'"></app-user>
Object.getOwnProperties() && UserComponent.prototype.ng....=xxxx-[username]
let controller=new UserComponent();
controller.username=xiaodong
子组件会给自己的类的原型上打上标签，父组件在使用子组件，构建标签的时候，会通过user
如子组件有一个@Input() name;父组件class UserComponent{}
属性装饰器接收两个参数（target，key），其实在父组件中，user会被打上标识，user.prototype.ng****;
子组件会通过该装饰器去找，发现有一个标识中有name属性，就传过来该值。
//调用的方法与被调用的方法在同一个类中，类名.可以省略不写。
public class MethodTest06 {
public static void main(String[] args){
// MethodTest06.m();
// 找的是当前类中的方法
// m();
A.doOther();
// doOther(); 直接调用其他类中的方法，编译报错。
}
public static void m(){
System.out.println("m方法执行了");
}
}
class A{
public static void doOther(){
System.out.println("A类中的方法执行了");
}
}
public class MethodTest11 {
public static void main(String[] args) {
// 方法在执行过程中，在JVM中的内存是如何分配的，内存是如何变化？
// 方法只定义，不调用，是不会执行的，并且在JVM也不会分配运行所属的内存空间呢
// JVM中有三块主要内存空间：
// 方法取内存。堆。栈
}
}
public class OverloadTest03 {
public static void main(String[] args) {
// 1.方法重载又被称为：overload
// 2.功能相似的时候，尽可能让方法名想同。
// 3.什么条件满足之后 构成了方法重载？
// 同一个类中，方法名想同，参数列表不同，数量不同。
// 方法重载的具体应用
System.out.println("hello world");
}
}
class U{
}
//子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。
// 如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
//如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
public class SuperClass {
private int n;
SuperClass(){
System.out.println("SuperClass");
}
SuperClass(int n){
System.out.println("SuperClass(int n)");
System.out.println("我是小傻子");
}
}
class SubClass extends SuperClass{
private int n;
// 自动调用父类的无参构造器
SubClass(){
System.out.println("SubClass()");
}
SubClass(int n){
// 调用父类的有参构造器
super(300);
System.out.println("SubClass(int n)");
}
}
class TestSuperSub{
public static void main(String[] args){
SubClass s1 = new SubClass();
SubClass s2 = new SubClass(100);
}
}
public class OOTest01 {
public static void main(String[] args) {
// 通过一个类可以实例化N个对象
// 实例化对象的语法：new 类名（）
// new运算符的作用是创建对象，在JVM堆内存中开辟新的内存空间。
// 方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间中
// 栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈。
// 堆内存：new的对象在堆内存中
// Student是一个引用数据类型；
// s是一个变量名；是一个局部变量，在栈内存中存储；
// new Student（）是一个学生对象；new运算符在堆内存中开辟的内存空间称为对象。
// 引用是一个变量，只不过这个变量中保存了另一个java对象的内存地址。
// 无法直接操控堆内存，java中没有指针，只能通过引用去访问堆内存当中的对象内部的实例变量。
Student s = new Student();
s.address = "beijing";
s.sex = true;
s.age = 10;
System.out.println(s.sex);
System.out.println(s.address);
System.out.println(s.age);
System.out.println(s.name);
System.out.println(s.no);
/*
* 通过类实例化一个全新的对象
* stu是一个引用；是一个局部变量；Student是变量的数据类型；
* 局部变量在栈内存中存储；
* 成员变量中的实例变量在堆内存的java对象内部存储；
* 实例变量是一个对象一份，100个对象有100份；
* no是实例变量，是对象级别的变量，变量存储在java对象的内部，必须先有对象，通过对象才能访问no这个实例变量，
* 不能直接通过类名.no;
* */
Student stu = new Student();
}
}
public class OOTest06 {
public static void main(String[] args) {
Student stu = new Student();
// String brand, String labelStyle, String color, Student stu
Computer computer = new Computer("apple", "ss","blue",stu);
// 实例变量必须先创建对象。
// stu是引用变量，是局部变量，变量中保存内存地址指向堆内存当中的Student对象。
// 访问实例变量的语法，引用.变量名。computer.color,color是实例变量
// 读取，修改computer.color="blue"
// stu.computer.color = "blue";
stu.name = "张三";
stu.computer = computer;
System.out.println(stu.name + "的笔记本是" + computer.brand);
}
}
//面向过程关注的是因果关系。
//Student是引用数据类型
//局部变量在栈内存
//静态变量在方法区内存
public class Student {
int no;
String name;
boolean sex;
int age;
String address;
Computer computer;
}
import address.Address;
public class User {
/*no，name,addr是一个实例变量
* int是基本数据类型；
* String是引用数据类型；Address是引用数据类型；
* address是一个引用；name是一个引用
* 不可变数据结构*/
int no;
private String name;
private Address address = null;
public void setAddress(Address address) {
this.address = address;
}
public Address getAddress() {
return address;
}
public User(int no, String name) {
this.no = no;
this.name = name;
}
void bar() {
}
}
package aboutThis;
/*
* 关于this:
* this是一个关键字，翻译为：这个
* this是一个引用，this是一个变量，this变量中保存了内存地址指向了自身。this存储在JVM堆内存java对象内部。
* 创建100个Java对象，每一个对象都有一个this，也就说有100个不同的this。
*
* 没有static关键字修饰的方法称为实例方法。访问？引用.
* 有static。类名.Customer.doSome
* 没有static关键字修饰的变量称为实例变量。
* 当一个行为、动作执行的过程中，是需要对象参与的，name这个方法一定要定义为实例方法。不需要static关键字修饰
* this可以出现在实例方法中，this指向当前动作的对象。
* this在多数情况下是可以省略不写的。
* this不能使用在static修饰的方法中。
*
* this可以使用在实例方法当中，代表当前对象
* 可以使用在构造函数中，通过当前的构造方法调用其他的构造方法【this(实参)】
* */
public class Customer {
// 【name：堆内存的对象内部中存储，所以访问该数据的时候，会先创建对象，】
String name; // 没有被static修饰，因此是实例变量，需要通过引用.的方式访问。
public Customer(){
}
// 每一个顾客的行为不一样，属于对象级别的行为
// 以下方法定义为实例方法，因为每一个顾客在真正购物的时候，最终的结果是不同的。所以这个动作在完成时必须有对象的参与。
public void shopping(){
System.out.println(this.name+"在购物");
}
//执行过程中没有“当前对象”，因为带有static的方法是通过类名的方式访问的。
// 或者上下文中没有当前对象。自然不存在this(this代表的是当前正在执行这个动作的对象）
public static void doSome(){
// doSome方法调用不是对象去调用，而是类名去调用，执行过程中没有当前对象。
// name是一个实例变量，下面含义是访问当前对象的name
// static方法的调用不需要对象，直接使用类名
// 创建对象
Customer c = new Customer();
System.out.println(c.name); //此时name使用引用的方式访问，访问的是c引用指向对象的name
}
}
//git reset --soft HEAD^
//git stash list 查看stash列表
//git stash save '保存暂存区的更改'
//git stash apply stash@{0} 应用暂存的更改i
//git stash show -p stash@{0} 查看暂存区的某个更改
//git stash drop stash@{0} 从暂存区删除
package duotai;
/*
* 概念：
* 向上转型：子类型-父类型；自动类型转换。
* 向下转型：父类型-子类型：强制类型转换。
* 上述两种方式的存在，要求必须是父子继承关系。*/
public class Test {
public static void main(String[] args) {
// new Cat()创建的对象类型是cat,a2这个引用的数据类型是Animal，他们之间进行了类型转换。
Animal a2 = new Dog();
// java分编译和运行阶段
// 先编译后运行，
// 编译阶段，检查a2这个引用的数据类型为Animal，Animal.class这个字节码当中有move（）方法，编译通过。这个过程为
// 静态绑定，编一阶段绑定。只有静态绑定成功之后，才有后续运行。
// 运行阶段：JVM内存当中真实创建的对象为Cat对象，以下程序在运行阶段一定会调用Cat对象的move方法。此时发生了程序的
// 动态绑定。
// 无论cat是否重写move方法，运行阶段一定调用Cat对象的move方法，因为底层真是对象就是Cat对象。
a2.move();
// 编译阶段，检查a2这个引用的数据类型为Animal；从Animal.class字节码文件中找catchMouse方法，最终没有找到
// 导致静态绑定失败，即编译失败
// a2.catchMouse();
// 想要实现上述方法，需要强制类型转换，将Animal转换为Cat
// 当调用的方法是子类型特有的额，其父类型不存在，需要转换
Dog c2 = (Dog)a2;
c2.catchMouse();
Animal a3 = new Bird();
// Cat c3 = (Cat)a3;
// c3.catchMouse();
if(a3 instanceof Dog){
Dog c3 = (Dog)a3;
c3.catchMouse();
} else if(a3 instanceof Bird){
Bird b3 = (Bird)a3;
}
}
}
package overload;
//什么是方法重载:在同一个类中，方法完成的功能是相似的。建议方法名相同，就像在调用同一个方法。
//什么条件满足之后，g构成方法重载：在同一个类中，方法名相同，参数列表不同。
//方法重载和什么无关：方法的返回值类型，方法的修饰符列表
//方法覆盖（方法重写）
//当父类方法无法满足当前业务需求的时候，需要重新写父类的方法。
//方法重写发生在具有继承关系的父子类之间。，返回值类型相同，方法名相同，形参列表相同。
//私有方法、构造方法不存在继承，不能实现覆盖
public class Test01 {
public static void main(String[] args) {
try {
new Test01().run(1);
} catch (Throwable e) {
e.printStackTrace();
}
}
//exception
//error
public void run(int a) throws IllegalArgumentException {
throw new IllegalArgumentException();
}
}
package objectAnd;
/*
* 方法调用的时候，涉及到参数传递问题的时候，java只有一种语法机制，就是讲变量中保存的只传过去了，
* 只不过有时这个值是字面值，有时这个值是另一个java对象的内存地址。*/
public class Test02 {
public static void main(String[] args) {
User u = new User(20);
add(u);
System.out.println("main"+ u.age);
}
public static void add(User u){
u.age++;
System.out.println("add"+u.age);
}
}
class User{
int age; // 实例变量
// 构造方法
public User(int i) {
age = i;
}
}
package conMethod;
/*
* 构造方法的作用：
* 1.创建对象；
* 2.创建对象的同时，初始化实例变量的内存空间；
* 成员变量之实例变量（对象变量），属于对象级别的变量，必须先有对象，才能有实例变量。
* 实例变量没有手动赋值的时候，系统默认赋值在什么时候完成？
* 是在类加载的时候吗？不是。因为类加载的时候，只是加载了代码片段，还没来得及创建对象，此时实例变量没有初始化。
* 实际上，实例变量的内存空间是在构造方法执行过程中完成开辟的，完成初始化的。*/
public class Test02 {
public static void main(String[] args) {
// 创建对象，给对象的属性赋值
//
Account act1 = new Account();
act1.setActno("no");
System.out.println(act1.getActno());
act1.setBalance(10.00);
System.out.println(act1.getBalance());
Account act2 = new Account("有参数构造器");
System.out.println(act2.getActno());
}
}