目录
使用父类指向父类，父类没有方法，子类有方法（instanceof指向真实子类）
面向对象的三大特征：封装，继承，多态
类的创建包里分两种：一个是对象的静态属性，一个是对象的动态方法，
静态属性：比如在类里面用int，double，string 定义一个属性，可以在对象里面进行调用赋值
动态方法：方法就是直接进行一个if，for，do-while等的选择或循环的操作，可以在对象里面直接进行调用
1.类名
//类名
public class Integral {
//积分属性
int integral;
//卡类型属性
String type;
//方法名
public void show(){
if (integral >= 1000 & "金卡".equals(type) || integral > 5000 & "普卡".equals(type)){
System.out.println("回馈积分500分！");
}else {
System.out.println("积分不足！");
}
}
}
2.对象
public static void main(String[] args) {
类名 对象名 = new 类名()；
Integral scorecard =new Integral();
System.out.print("积分：");
//调用属性
对象名.属性 = 赋值
scorecard.integral = sc.nextInt();
System.out.print("卡类型：");
scorecard.type = sc.next();
//调用方法
对象名.方法名
scorecard.show();
}
3.类的无参
类的四种方法：无参无返，无参有返，有参无返，有参有返
无参无返
例：public void 方法名(){
System.out.println("你好！")
}
无参无返public后面用void
无参无返void在创建的对象调用是可以直接调用，用对象名.方法名();即可调用
无参有返
无参有返public后面需要用int，double，string类型，
例：public class Relation {
int num;
public int max(){
int num = 1;
return num(或结果);
}
}
成员变量相当于一个类的内部属性，可以设置多个成员变量(int,double,string等)，成员变量会赋予初始值，如：int = 0；double = 0.0；string = null；
局部变量是方法中新增的变量，方法中的选择结构，循环结构里的变量也是局部变量，局部变量则不会赋予初始值
1，当成员变量和局部变量相同时，优先调用局部变量，但是在同一个局部里，变量名不能重名！
2，一个类里局部变量可以调用成员变量，只需要在变量前面加上this.变量名，而成员变量则无法调用局部变量。
3，无参有返在输出上用return做结束，在return后面添加结果（也就是一个变量）return后面只能跟一个结果也就是一个变量，同理return的作用是让一个方法结束，通常写在一个方法的最后一行，if选择结构除外
4，同一个类里面的方法调用不需要在次创建变量，只需要在return后面跟方法名
例：
class A{
public int getSum(){//方法一
return 结果;
}
public double getAvg(){
//方法二调用方法一只需要在return后面跟被调用的方法名
return getSum() * 1.0 / 3;
}
}
4.类的有参
有参可以分为基本数据类型和引用数据类型，分为形参和实参，形参没有实际的值，只有初始值，实参是调用方赋值后转为实参，形参和实参要严格对照，实参在调用的时候不能写类型
public(修饰符) void（无返）对象名（类型 变量名）可以根据需要设置多个类型多个变量名如：public void calc1(int num，string name，int max...)
需要注意的是要按照顺序进行赋值输出，
基本数据类型参数：java基础的八大数据类型（整形：byte，short，int，long，浮点：float，double，字符：char，布尔：boolean）
基本数据类型的传参，只会把数值本身传递给调用者，不会进行运算
例：
public(修饰符) void（无返）对象名（类型 变量名）
public void calc1(int num){
num = num+1;
}
引用数据类型参数：可以用string，数组，对象做为参数
基本数据类型传参的使用：
String传参的使用：
接收和输出两个不可或缺，缺少程序将会出错
String数据类型传参被定义后会变成常量，被final修饰符进行修饰，无法更改变量赋值，需要增加新的String变量接收调用方传输的数据
//<类>String作为参数，s为变量名
public void app(String s){//接收
s = s + "+++";
System.out.println(s);
}
//<对象>
public static void main(String[] args) {
App App = new App();
String s = "123";//给s赋值
App.app(s);//输出类 s = s + "+++"
System.out.println(s);//输出 s = "123"
}
数组传参的使用
引用数据类型参数：可以用string，数组，对象做为参数
5.封装和static的作用
static的作用和使用
static可以用来修饰变量，普通方法，提升到类级别，被static修饰后只能用类名调用，
static（静态修饰）被修饰后的变量会转为静态变量，被其他类调用是可以直接进行调用，不用创建对象，调用方法：类名.方法名
static的调用和final相似，不用创建对象可以直接进行调用，static的调用方法：类名.方法名
例：
封装的作用和使用（private/私有的）
封装做为java面向对象三大特征之一，作用：追求程序的安全性
意义：
将类的某些信息隐藏起来，只提供对外开放的接口，那么我们就可以在这个接口中编写限制/保证数据或程序安全的逻辑代码
优点：
便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性（防止一个功能出现问题，导致整个系统都不能使用）
提高软件的可重用性（一次编写，多个地方都可以使用）
降低了构建大型系统的风险
封装的使用
第一步：隐藏类中的某些信息
使用private进行修饰后，变量或者方法会隐藏起来，其他类将无法被调用及修改！
注意：如果private修饰后面有static静态进行修饰，调用是可以直接使用：类名.get方法 直接调用，如果没有static静态修饰符，则需要new出当前类的对象进行调用：对象名.get方法 调用。
例：
第二步：提供对外方法，可以让别的类进行调用
一个隐藏信息需要用两个方法（set方法/get方法）set安排，get得到。
注意：对外方法的生成可以使用快捷键进行（Alt+lnsert）
第三步：在方法中编写限制的逻辑代码:以防止使用者对属性随意赋值，这样可以保证数据的安全性
this关键字：表示当前对象
调用者就是this，谁是调用者谁就是this
作用：
使用this调用成员变量，解决成员变量和局部变量的同名冲突（主要使用）
使用this调用成员方法，this可以省略，直接调用print();
如果使用this调用重载的构造方法，只能在构造方法中使用，必须是构造方法中的第一条语句
封装后在外部对变量进行修改重新赋值
封装之后在其他类修改赋值的时候，需要对set变量方法重新传参，需要对get变量方法重新赋值后再传给set变量方法
6.继承
继承的作用和使用方法
继承是java面向对象三大特征之一，追求代码的重用性，
重用性：一次编写多地方使用，节省代码，提高效率，
两个类及两个以上的类中有相同变量或方法，可以使用继承来完成，可以设置一个父辈类把相同的变量或方法提取出来，使用者可以直接继承父辈，
继承（extends）的书写：
父类：正常创建public class 类名即可
子类：创建public class 类名后要使用extends 父类名进行继承
继承的注意事项：
1.和父类同包的子类，可以调用public，protected和默认修饰符
2.不和父类同一个包的子类，不能调用默认修饰符
3.父类的private私有修饰符不能被子类所调用
父类变量的使用：
子类调用父类变量时，可以直接使用new出的子对象名.set变量名或get变量名直接调用或传参，如果父类变量被static修饰后，调用方是可以直接使用子类名.父类set变量名方法进行赋值或调用
继承方法重写（override）
使用场景：当父辈方法不足以完成程序时，就需要在子类中进行方法重写，
重写方法：子类重写父类必须要和父类的修饰符和对象名保持一致
规则：
首先必须要有继承关系——————子类重写父类的方法
重写方法和被重写方法必须具有相同的方法名
重写方法和被重写方法必须具有相同的参数列表
重写方法的返回值类型必须和被重写方法的返回值相同或者是其子类
重写方法不能缩小被重写方法的访问权限
super的作用 ：重写之后将不会再运行父辈方法，只会运行子类，如果既想保留父类，又想运行子类，则可以用super.方法名进行保留父辈
7.多态和instanceof
多态的作用和使用
多态作为java面向对象三大特征之一，追求的是提高代码，系统的扩展性！
定义：同类型的对象，执行同一个行为，会表现出不同的行为特征
实现多态的三个要素：
1.多态是依附于继承的一种特征，需要在父类做一个无参无返的方法，不需要编译内容
2.子类需要重写父类方法或创建一个子类独有的方法
3.独立建一个新类，父类指向父类或使用instcnceof使指向父类转成真实的子类
指向类型有三种：
1.父类指向父类
2.父类指向子类
3.子类指向子类
注意：子类不能指向父类
使用父类指向父类，父类里面有方法
1.创建一个父类无参无返的方法
2.子类重写这个无参无返的方法
3.创建一个类(可以理解为多态类，不用继承父类)，做一个父类指向父类的方法，调用时会先执行多态类里面的方法程序，再执行子类重写的方法，末尾做一个父类.方法(),指向父类的方法，父类方法已被子类重写，等于指向子类.方法名()
4.调用方法: 创建的多态类new出一个对象，用对象名.多态里的方法名（new出来的子类对象名）
例：
子类为Dog类，在测试类中需要new一个对象出来
调用父类的类为See
Dog dog = new Dog；//new的子类对象
//省略程序.......
See adopt = new See；//new的多态对象
adopt . i（dog）；//多态对象名 . 多态类里的方法（子类对象名）
使用父类指向父类，父类没有方法，子类有方法（instanceof指向真实子类）
当一个方法独属于子类，且多态类方法形参填写时，仍是父类指向父类，但这时父类并没有此方法，这是需要使用instanceof指向真实的子类
instanceof使用方法：
父类没有方法，子类独有的方法
public void play(Pet pet){//父类指向父类形参
if(pet instanceof Dog){//父类形参指向真实的子类
Dog dog = (Dog)pet;//new一个子类对象，将父类形参强转为子类，也可以理解为指向真实的子类
dog.catchingFlyDisc();//直接使用new出的子类对象名.调用子类独有方法
下列如上：
}else if(pet instanceof Penguin){
Penguin penguin = (Penguin) pet;
penguin.swimming();
}else if(pet instanceof Cat) {
Cat cat = (Cat)pet;
cat.hide();
}
8.final和构造器的使用
final的使用
final作为修饰符，被final定义后变量将转为常量，无法被转变，
如何用final定义常量：public static final 类型 常量名 = 赋值；
例：
final的调用方法：类名.常量名；
例：
final修饰变量，方法，类的使用
final修饰方法：
如果父类方法不想被子类重写，可以使用final进行修饰，但是这个方法可以在当前类多次重载
final修饰类：
被修饰的类不能被继承，而且这个类中的方法会默认被final修饰
final修饰变量（基本数据类型）：
被修饰的变量将会转变为常量，无法再进行改变，如果使用final进行修饰变量，这个变量需要设置一个初始值，这个初始值将无法进行改变
final修饰引用数据类型：
被修饰的引用数据类型地址将无法改变，但是地址中储存的信息可以进行修改
举例：final修饰引用数据类型
final Student student = new Student();
student.setStudentNo("10001");
student.setStudentName("张三");
//student = new Student();//final修饰的student不能被重新赋值为其它对象
//final修饰的student的内容可以改变
student.setStudentName("李四");
student.setStudentNo("10005");
//int是基本数据类型，但是int数组是引用型数据类型
final int[] nums = {1,2,3,4,5};
//nums = new int[10];
nums[0] = 5;
构造器的使用（Constructor）
构造方法分为无参构造和有参构造，构造方法快捷键：Alt+lnsert
语法：
访问修饰符 类名(参数){
//初始化对象
}
作用：创建并初始化对象！！！
分类：无参构造和有参构造
有参构造方法的创建：访问修饰符 类名（参数）
有参构造方法的调用
*注意：构造变量写入时要注意写入顺序
重点需要注意！！！
当父类的变量供多个子类使用，但每个子类使用时参数不同，则可以对父类做一个有参构造，对父类变量进行传参，继承的子类则需要写一个子类有参构造，传参给父类，在测试类中new出的子类对象后面直接写入参数即可
方法重载
同一个类中，方法名相同是可以进行方法重载
括号里面参数变量不同，参数数量不同，顺序不同，返回值不同均可方法重载
9.抽象类
抽象类的作用和使用方法（abstract）
抽象类和普通类的区别
1.抽象类在class前面需要用abstract进行修饰，普通类则没有修饰
2.抽象类不能被示例化(也就是不能创建对象，抽象父类不能new抽象父类，但可以抽象类new子类，直接指向子类)，普通类可以实例化创建对象。
3.如果有抽象方法，那这个类必须为抽象类，子类继承抽象类，必须重写抽象方法，抽象类中可以有变量有普通方法。普通类中不能有抽象方法！
抽象方法和普通方法的区别
1.抽象类没有方法体，普通类必须有方法体。
2.抽象方法必须存在于抽象类和接口里。
3.抽象方法需要用abstr进行修饰。
接口的作用和使用方法（interface）
接口的作用：
接口是一个方法的集合，用来约束类的行为，用于解耦合，接口中的方法，实现类必须全部实现！
1.在项目程序中进行维护，升级，扩展等行为，可以创建接口进行，切记不要更改项目源码
2.在实际项目开发中，将相同/相似的方法放在同一个接口中，也就是按照业务或区块划分
举例：实际开发一个学生住宿管理系统
分析：模块假如有两个：学生信息、宿舍信息
学生的增删改查方法放在一个接口中
宿舍信息的增删改查方法放在一个接口中
接口的使用及注意事项：
1.创建类是选择interface，如果直接创建了类包，则直接把class修改为interface即可。
2.接口只能创建常量和抽象方法
接口中的变量，会默认使用public static final进行修饰，变为全局静态常量！
接口中的方法，会默认使用public abstract进行修饰，转变为抽象方法，不具备方法体！
注意：创建方法时直接返回值类型 方法名即可，可以直接省略修饰，创建常量直接类型 变量名即可，省略前面的修饰
3.接口之间可以存在继承关系，接口A可以通过extends 接口B进行继承，接口A不能对接口B的方法进行定义，如果实现类C继承了接口A，那么实现类C除了A接口的方法，B接口的方法也必须实现！一个接口可以同时继承多个接口，如：接口A extends 接口B，接口C，接口D......
注意：一个类只可以继承一个父类，但是可以继承多个接口，实现类继承接口需要用implements，接口继承接口需要用extends
注意：如果一个类既继承了父类，又实现了接口，那么通常在创建该类对象时，一般都是使用自己的引用指向自己的对象
面向接口编程的优点：
1.降低代码间的耦合性
2. 易于程序的扩展，提高了程序的可扩性性
3.提高了程序的可维护性
接口体现了约定和实现相分离的原则
接口构成系统的骨架
面向接口编程就意味着：开发系统时，主体架构使用接口，接口构成系统的骨架，这样就可以通过更换实现接口的类来实现更换需求。
个人理解：在做实际项目的时候，可以先用接口抽取方法，然后对接口方法进行实现，做到只暴露接口，不暴露内容，测试类调用时，只调用实现接口的类。
面试题：抽象类和接口的联系和区别？
相同点：
1.代表系统的抽象层
2.都不能被实例化
3.都能包含抽象方法：用于描述系统提供的服务，不必提供具体实现
不同点：
1.抽象类有构造方法，接口没有
2.抽象类可以有非抽象方法，但接口中只能有抽象方法
3.抽象类中可以有普通的成员变量，但是接口中只能存在全局静态常量
4.抽象类便于复用，接口便于代码维护/扩展
5.抽象类只能被单继承，接口却可以多实现
面向接口编程示例：
创建接口方法的时候，直接创建实现类，继承并实现接口方法
第一步：创建接口方法
第二步：创建实现类，继承接口，实现接口方法
第三步：调用实现类，插入到子类中，（在子类创建对应的方法，在方法里面调用实现类）
10.面向接口编程简易流程图
11.面向对象七大设计原则
一，单一职责原则
一个类只负责一个功能领域中的相应职责或一个职责。
二，开闭原则 *
软件实体应对扩展/升级开放，对修改关闭。
三，里氏代换原则
所有引用基类对象的地方，都能够透明的使用其子类的对象。
四，依赖倒转原则
抽象不应该依赖于细节，细节应该依赖于抽象。
五，合成复用原则
尽量使用对象复用，而不是使用继承达到复用的目的。
六，接口隔离原则
使用多个专门的接口，而不使用多方法的单一接口。
七，迪米特法原则
一个软件实体尽量不要接触过多的其他实体类，例如：不要跨过女朋友找她闺蜜，而是通过女朋友找她闺蜜。
这7种设计原则是软件模式必须遵守的原则，每个原则的侧重点不同，其中：【开闭原则】是总纲，它告诉要【对扩展开发/升级开放，对修改关闭】；【里氏代换原则】告诉我们【不要破坏继承体系】；【依赖倒置原则】告诉我们要【面向接口编程】；【单一职责原则】要告诉我们一个【实现类要职责单一，不能多干，也不能少干，更不能全干】，也就是定义一个类，去实现类的封装；【接口隔离原则】告诉我们在设计接口的时候要【精简单一】；【迪米特丝原则】告诉我们要【降低耦合度】；【合成复用原则】告诉我们【优先使用对象组合或聚合等关系复用，少用继承关系复用】；
4837
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
