面向过程: 步骤清晰简单，第一步第二步做什么
面向对象:物以类聚，分类的思维模式。
三大特性: 封装 继承 多态
异常抛出 :
/*
修饰符 返回值类型 方法名()
{
//方法体
return 返回值;
}
*/
public String SayHello()
{
return "Hello World";
}
public int max(int a,int b)
{
return a>b?a:b;//三元运算符
}
//数组下表越界：Arrayindexoutofbounds
public void ReadFile(String file) throws IOException
{
?
}
//静态方法 static
// 非静态方法
//实例化这个类
//对象类型 对象名 = 对象值
public static void main(String[] args) {
Student student = new Student();
student.say();
}
public class Student {
//方法
public void say()
{
System.out.println("学生说话了");
}
//和类一起加载
public static void a()
{
//b();
}
//类实例化之后才存在
public void b()
{
?
}
}
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
int add = Demo03.add(1,2);
?
}
public static int add(int a,int b)
{
return a+b;
}
//值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
Demo04.change(a);
System.out.println(a);
}
//返回值为空
public static void change(int a)
{
a = 10;
}
}
?
//引用传递：对象，本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
Demo05.change(person);
System.out.println(person.name);
}
public static void change(Person person)
{
//person是一个对象：指向的是person类
person.name = "刘涛";
}
}
//定义了一个Person类，有一个属性:name
class Person{
String name;
?
}
动物 植物 手机 电脑
Person类 Pet类 Car类等 这些类都是用来描述/定义某一类事物应该具有的特点和行为
张三就是人的一个具体实例 张三家的旺财就是狗的一个具体实例
能够体现出特点，展现出功能的是具体实例，而不是一个抽象的概念
使用new关键字
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的赋值
构造器也叫构造方法，与类名相同，没有返回值。
/** public static void main(String[] args) {
//类:抽象的，实例化
//类实例化后会返回一个自己的对象
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name = "小明";
xiaoming.age = 3 ;
?
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xh.name = "小红";
xh.age = 3;
System.out.println(xh.name);
System.out.println(xh.age);
?
?
构造器:
1 和类名相同
2 没有返回值
作用
1 new本质在调用构造方法
2 初始化对象的值
注意点
1 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
快捷键: alt + ins
}
**/
类与对象 类是一个模板：抽象。对象是一个具体的实例
方法 定义，调用！
对应的引用 引用类型：基本类型（8） 对象是通过引用来进行操作的：栈--->堆
属性：字段Field 成员变量 默认初始化
修饰符 属性类型 属性名 = 属性值；
对象的创建和使用: 必须使用new关键字创造对象，需要有构造器 对象的属性 对象的方法
类 静态的属性 属性
封装 集成 多态
程序设计要求 高内聚，低耦合。高内聚就是类的内部数据操作由自己完成，不允许外部干涉；低耦合；仅仅暴露少量的方法给外部使用。
通常应该禁止直接访问一个对象中的数据的直接表示，而是通过操作接口来访问，这成为信息隐藏。
记住这句：属性私有，get/set
//属性私有
//名字
private String name;
//学号
private int id;
//性别
private char sex;
private int age;
?
public int getAge() {
return age;
}
?
public void setAge(int age) {
if(age>100&&age<3)
?
{this.age = age;}
else{
age = 3;
}
}
?
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get 获得这个数据
public String getName()
{
return name;
}
//set 给这个数据设置值
public void setName(String name)
{
this.name = name;
?
}
//alt + insert
?
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;
}
/**
* 1 提高程序的安全性，保护数据
* 2 隐藏代码的实现细节
* 3 统一接口
* 4 系统的可维护性增加了
*/
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是扩展，子类是父类的扩展
JAVA中只有单继承，没有多继承（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖 组合 聚合等
继承关系的两个类，一个为子类（派生类），一个为父类。子类继承父类，使用关键字extends表示
子类和父类之间，从意义上讲应该具有 is a 的关系
object 类
//Person 人 :父类
//在JAVA中所有的类都默认直接或者间接继承Object类
public class Person {
public int money = 10_0000_0000;
public void say()
{
//public
//protected
//default
//private
//ctrl+h
?
System.out.println("说了一句话");
}
//Student is Person:派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person
{
?
}
super - this
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法过着构造方法中
3.super和this不能同事调用构造方法
区别
代表的对象不同
this；本身调用者这个对象
super:代表父类对象的应用
前提
this：没有继承也能使用
super：只能在继承条件才可以使用
构造方法
this（）:本类的构造
super（）：父类的构造
子类默认调用父类的无参构
需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大： private>protected>default>public 子类的修饰符范围可以比父类大
4.抛出的异常:范围可以被缩小，但不能扩大。
重写，子类的方法和父类的方法必须一直，方法体不同
为什么需要重写：
1.父类的功能子类不一定需要，或者不一定满足
Alt+Ins；Override
同一个方法可以根据发送对象的不同而而采取多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多(父类，有父系的类)
多态存在的条件
1 有继承关系
2 子类重写父类方法
3 父类引用指向子类对象
注意多态是方法的多态，属性没有多态
/**
* 多态注意事项：
* 1 多态是方法的 多态，属性没有多态
* 2 父类和子类有联系 类型转换异常 ClassCastException!
* 3 存在的条件：继承关系，方法需要重写 父类的引用指向子类对象!father f1 = new son();
*
* static 方法，属于类，他不属于实例
* final 常量
* private方法
*/
//一个对象的实际类型是确定的
//可以只想的引用类型就不确定了 父类的引用指向子类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
假设A是B的子类,并且A重写了B的run方法
现有
A a = new A();
B b = new A();
a.run会调用A中重写的run方法，如果没有重写则会调用B中的run方法
instanceof (类型转换) 引用类型 判断一个对象是什么类型～
//System.out.pritntln(X instance Y);//能不能编译通过，XY必须有父子关系
就是问X是不是Y的有血缘关系的长辈，有的话就是true
/**
*1 父类的引用指向父类的对象
* 2 子类的转换为父类，向上转型
* 3 父类转换为子类，向下转型，强制转换
* 4 方便方法的调用，减少重复的代码!简洁
*
* 抽象：封装 继承 多态 ！！抽象类，接口
*/
同一个类下的非静态方法可以调用同一个类下的静态方法，因为类一加载，静态方法就存在了
{
//2 赋初始值
//匿名代码块（创建对象时，在构造代码之前）
System.out.println("匿名代码块");
}
static {
//1.只执行一次
System.out.println("静态代码块");
//静态代码块（类一加载就直接执行，只执行一次）
?
}
public Person()
{
System.out.println("构造方法");
}
?
import static java.lang.Math.random;
import static java.lang.Math.PI;
?
//静态导入包
//约束～有人帮我们实现～
//abstrac 只有方法名字，没有方法实现
?
//1.不能new抽象类，只能用子类去实现它：约束！
//2.抽象类中可以写普通的方法
//3.抽象方法必须写在抽象类中
//抽象的抽象：约束！
?
//思考题？ 抽象类不能new出来，存在构造器吗？ 存在，反编译是存在的
//抽象类存在的意义？ 提高开发效率
?
普通类：只有具体实现
抽象类：具体实现和规范都有
接口：只有规范！专业的约束，约束和实现分离：面向接口编程
作用
1.约束
2.定义一些方法，让不同的人实现～ 10---->1
3.public abstract 方法
4.public static final 常量
5.接口不能被实例化～ 接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法
内部类就是一个类的内部再定义一个类，比如A类中定义一个B类，那么B类就相对于A类是内部类
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);
}
}
?
}
//一个java类中可以有多个class类，只能有一个public class类
局部内部类
public void method()
{
class Inner
{
public void in()
{
}
}
}
原文：https://www.cnblogs.com/noblehacker/p/13237488.html