面向对象oop
以类的方式组织代码，以对象的形式封装数据。
三大特性：封装，集成，多态。
new一个对象意思就是实例化一个类。
对象类型 对象名=new对象值；
静态方法不能直接调用非静态方法。
java是值传递。
一个项目应该只存在一个main方法。
对象就是new出来的。
=======================================
构造器
一个类，即使什么都不写，也不是空的，默认会有一个构造器。
public 类名（）{
}
同一个类下的方法中，要调用这个类里的属性，只能用this关键词，这是目前我的认知，以后可能会有不一样的看法。
1，使用new关键词必须要有构造器。
2，默认的构造器是没有参数的，没有返回值，但是如果你自己写一个有参数的构造器，就必须也要把没有参数的构造器写出来。
3，构造器是用来初始化值的。
快捷键：alt+inster可以用来快速生成构造器。
如果你在new的时候，加入了参数，idel会自己匹配相同参数的构造器。
===================================================================================
封装详解
追求“高内聚，低耦合”。
用private关键字来私有化属性，这些属性就不能随便调用了。
可以用get和set等方法对这些私有化属性进行调用，setName进行设置，getName进行调取。
private String na;
public String getName(){
return this.na;
}
public void setName(String name){
this.na=name;
}
public static void main(String[] args) {
Student st = new Student();
st.setName("bin");
System.out.println(st.getName());
}
===========================================================
用alt+insert快捷键可以生成get和set方法。
属性就可以先用private私有化，然后通过get，set方法封装，设置一些条件。
封装的好处就是提高程序的安全性，保护数据，隐藏代码的实现细节。统一接口，增加可维护性。
===============================================================
继承是对某一批累的抽象。
extands的意思是扩展，就是靠这个关键词来继承。
java中的类只有单继承，没有多继承。
继承类成为子类或者派生类，被继承类成为父类或基类。
子类继承父类，就会拥有父类全部public的属性和方法。
四个修饰符有：public，protected，default，private。
ctrl+h快捷键可以打开继承树界面，看清楚继承关系。
在java中，所有类都默认继承object类。
===================================================================
和this关键词相对应的super关键词是用来调用父类的非private的属性和方法的，私有的属性和方法无法被继承。
====
this（）；这样就是调用自己类的无参构造器。
super（）；就是调用父类的无参构造器。
但这两个都要写在代码的第一行，所以这两个不能一起写。
new一个子类，程序运行时，在运行子类的无参构造器时，会自动调用父类的无参构造器。
如果父类写了有参数的构造器，导致无参构造失效，那子类的无参构造器也会失效。
所以，我们写了一个有参构造器时，一定更要再写一个无参构造器。
==========================================================
super总结：
super（）；是调用父类的构造器的，而且必须在第一行；
super只能出现在子类中；
super（）；和this（）；不能同时调用构造器。
============================================================
方法重写
重写只有继承类中才有，子类重写父类的方法。方法名必须相同，参数列表也要相同。
重写不能写静态方法，只能写非静态方法。
重写时父类不能是private方法，子类的修饰词范围要大于父类的。
抛出的异常，范围只能缩小，不能扩大。
重写的原因有：父类的功能子类不一样需要，或者不一定够满足；
快捷键是alt+insert
===================================================================
多态
一个对象的实际类型是确定过的，但指向的引用类型可以是不确定的。
父类的引用可以指向子类。
public class A extends B{}
A继承了B类之后：
public class Application3 {
public static void main(String[] args) {
A a = new A();
B b =new A();
}
}
对象b能执行的方法是看对象左边的B类型。但是如果子类A中重写了父类B的方法，那就是执行A中的方法。
b如果要执行A中的方法，可以强制转换（（A）b）.方法名；
注意事项：
多态是方法的多态。
多态只存在于继承关系类中，不然就会出现类型转换异常（ClassCastException！）
所以要有继承关系，子类方法要重写，父类的类型要指向子类（father f1=new son（）；），才会出现多态。
static，final，private修饰的方法都不能重写。
============================================================================
instanceof
这个字符用来判断两个类之间有没有继承关系,有关系就是true。
B b =new A();
System.out.println(b instanceof A); //true
================================================================================
类型强制转换
继承类中，父类对象要转换成子类要强制转换。
Person person = new student();
Student stu = (Student)person;
stu.子类方法名；
下面两行也可以写成（（Student）person）.子类方法名；
子类对象转换为父类可以直接转换，但是可能会丢失一写子类自己的方法。
==============================================================================
多态总结：
父类引用指向子类对象，父类对象强制转换为子类，子类对象转换为父类，这些情况可以方便调用一些方法
=============================================================================
static关键字
非静态的属性或方法，不能直接用类名.去调用，要先new出一个对象再加.去调用；今天的方法可以直接掉，类名.这个都可以省略不要。
static代码块只会执行一次。
static可以做静态导入包：import static java.lang.Math.randpm;
==============================================================================
抽象类
abstract：
public abstract class Action {
}
抽象的方法只有抽象名字，没有方法实现。
public abstract void something();
如果有子类继承了一个抽象类，那这个子类一定更要重写这个抽象方法。除非这个子类也是一个抽象类，就不用重写方法。
抽象类不能new出来，只能靠子类实现。
抽象类中可以写正常的方法。但是抽象方法只能写在抽象类中。
=============================================================
接口
只有规范，无法自己写方法。
接口的本质是契约。
接口中的所有定义都是默认抽象的。
用interface来实现
public interface Action {
void add(String name);
}
接口都需要有别的类去实现。
类去实现接口用关键词implements，并且必须重写接口的方法。
public class UserImpl implements Action，TimeServe{
@Override
public void add(String name) {
}
}
接口可以多个实现，侧面实现多继承。
接口中定义的属性都是常量。
========================================================
内部类
就是在一个类的里面再定义一个类。
内部类可以获得外部类的私有属性和方法
public class Demo3 {
private int id;
public void out(){
System.out.println("外部类");
}
public class Inner{
public void in(){
System.out.println("内部类");
}
}
}
-----------------------
public class Demo4 {
public static void main(String[] args) {
Demo3 demo3 = new Demo3();
Demo3.Inner inner = demo3.new Inner();
inner.in();
}
}
------------------------------------------------
如果再内部类中加static关键词，那这个内部类就不能获得非静态属性了。
------------------------------------------------
如果在方法里面定义一个类，那就是局部内部类
----------------------------------------------
如果new出的类没有给名字，那就是匿名内部类
public class Demo5 {
public static void main(String[] args) {
new Apple().eat(); //没有给出一个具体对象也可以。
}
}
class Apple{
public void eat(){
System.out.println("apple");
}
}
原文：https://www.cnblogs.com/jmfy/p/14490107.html