面向对象（Java）
| 开闭原则： | 抽象约束，封装变化 |
| 里氏替换原则： | 子类可扩展父类但不能改变父类 |
| 依赖倒置原则： | 面向接口编程 |
| 单一职责原则： | 控制类粒度大小，使其利于重用 |
| 接口隔离原则： | 为提高内聚性，降低类对接口依赖性，分解接口 |
| 迪米特法则： | 限制类实体间通信宽度和深度 |
| 合成复用原则： | 尽量使用聚合或组合关系 |
设计模式：单例模式，懒汉式、饿汉式，装饰器模式，观察者模式
类与对象：类是对象的抽象，对象是类的具体。
类：具有相同属性和方法的一组对象的集合。
对象：每个分类中，具体的个体，用来描述一组客观事物的实体，由一组方法和属性构成。
方法名的定义遵循驼峰原则。
方法调用：本类中：方法名（）；其他类中需要创建对象并调用。
形参：定义方法时，括号中创建的变量。
实参：在方法调用时，传入的实际参数。
注意：基本数据类型作为参数传递时传入的时值！引用数据类型作为参数传递时传递的是地址！
构造方法：若类中没有自定义构造方法，系统默认创建一个无参构造方法，但若自定义了构造方法，系统将不再默认创建无参构造方法。
构造方法的重载：方法名相同，参数项不同，与修饰符无关。
this(...):调用构造方法时必须放在第一行（如有参无参构造方法之间的调用 ...表示参数）。
idea集成开发工具: alt+insert:添加get 、set及构造方法快捷键。
成员变量与局部变量：成员变量在类中定义，有初始值，局部变量在方法中定义，没有初始值。
封装：防止属性被随意访问，不合理的赋值，两大原则：把尽可能多的东西藏起来；对外提供便捷接口，把所有属性藏起来
| 作用域修饰符 | 同一个类中 | 同一个包子类或其他类 | 不同包子类 | 不同包其他类 |
| private | √ | |||
| 默认修饰符 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
static静态变量域成员变量区别：静态变量属于类，也称类变量；成员变量属于对象，所以也称实例变量或对象变量；
成员变量存于堆内存，静态变量存于静态区；静态变量随类加载而加载，随类消失而消失；成员变量随对象创建而存在，随对象
消失而消失；静态变量可以通过类名或对象调用，成员变量只可通过对象名调用。类的创建先在栈内存创建加载对象的引用，在
共享区创建静态代码块，而后在堆里创建对象，创建成员变量成员方法。
| java.lang:虚拟机自动引入 |
| java.util:提供一些实用类 |
| java.io:输入、输出 |
继承：A extends B
super:代表父类对象，子类调用时放在第一行，子类对象默认调用父类构造函数，如果子类写明调用父类构造函数时，默认调用
父类的无参构造函数。若父类不存在无参构造，需要手动调用父类带参构造。
重写Override(重写的注解)：子类根据需求对父类方法进行重写，构造方法不能被重写。
package com.ibeifeng.javase.zuoye07;
public class Teacher {
private int tid;
private String course;
private String clas;
private String name;
public int getTid() {
return tid;
}
public String getCourse() {
return course;
}
public void setTid(int tid) {
this.tid = tid;
}
public void setCourse(String course) {
this.course = course;
}
@Override
public boolean equals(Object obj) {
Teacher teacher = (Teacher) obj;
if (!(obj instanceof Teacher)) {
System.out.println("请给定一个老师对象！！");
return false;
} else if (this.getTid() == teacher.getTid() && this.getCourse().equals(teacher.getCourse())) {
return true;
}else
return false;
}
public static void main(String[] args) {
Teacher teacher1=new Teacher();
Teacher teacher2=new Teacher();
teacher1.setCourse("本科");
teacher1.setTid(101);
teacher2.setCourse("本科");
teacher2.setTid(101);
System.out.println(teacher1.equals(teacher2));
}
}
| toString: | 返回当前对象信息，类地址@十六进制哈希值。(输出对象默认调用重写toString方法，以表现对象相关属性) |
| equals: | 比较两个对象内存，相同则返回true。 |
| hashCode: | 返回对象hash值 |
| getClass: | 返回类信息，class 类地址。 |
多态：程序中定义的引用变量，发出的方法调用并不确定，只在程序运行期间，才确定其具体指向哪个类的实例对象。这样不用
修改源代码，就可以让引用变量指向不同的类实现上，让程序可以选择多个运行状态。
核心是类型转换，向上转型、向下转型，提高程序扩展性。
使用场景：形参——参数既可以传入本类参数，又可以传入子类参数。作为父类方法的返回值——既可以返回本类对象，
又可以返回子类对象。
继承：提高代码可重用性，因此提高程序的维护性。子类又被称为派生类，父类又被称为超类（Super Class）。
黑白电视机类：
package com.ibeifeng.javase.zuoye07;
public class Black_and_whitePrinter extends Printer {
@Override
public String printType() {
return "打印黑白样式文章！";
}
public Black_and_whitePrinter() {
this.setName("黑白打印机");
}
}
彩色电视机类：
package com.ibeifeng.javase.zuoye07;
public class ColorPrinter extends Printer {
@Override
public String printType() {
return "打印彩色的文章!";
}
public ColorPrinter() {
//隐含super关键字，加载父类数据
this.setName("彩色打印机");
}
}
操作员：
package com.ibeifeng.javase.zuoye07;
public class Operator {
public void print(Printer printer){
System.out.println(printer.getName()+printer.printType());
}
public static void main(String[] args) {
Operator operator=new Operator();
operator.print(new ColorPrinter());
operator.print(new Black_and_whitePrinter());
}
}
打印：
package com.ibeifeng.javase.zuoye07;
public abstract class Printer {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract String printType();
}
instanceof:判断一个引用类型对象是否为该对象的实例。
抽象类：不能被实例化，（实例化必须有方法体）没有抽象构造方法，抽象类中可以有非抽象构造方法，
被子类构造方法调用
抽象方法特点：没有方法体，必须在抽象类中；必须在子类中被实现，除非子类是抽象类。
向上转型：（自动转型）只能访问父类被子类继承的方法和属性。
父类调用子类中重写方法，会执行子类中重写的方法体，父类可以被用作返回值或形参。
向下转型：父类引用转到子类对象（强制转换）。
package com.ibeifeng.javase.ketang06;
public class Tvs extends Goods {
private String NAME="电视机";
@Override
double printPrice() {
return 1000;
}
/*向上转型多用于方法参数及return返回参数,向下转型多用于对子类特有方法的使用
*通过构造方法修改父类属性值,若子父类存在共性则不用进行判断，若为子类特性，则进行判断是哪个子类
*若父类为高度抽象不需要写方法体时，可以用抽象类
* */
}
package com.ibeifeng.javase.ketang06;
public abstract class Goods {
private String name;
abstract double printPrice();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.ibeifeng.javase.ketang06;
public class Foods extends Goods {
private String name="食品";
@Override
double printPrice() {
return 100.0;
}
}
package com.ibeifeng.javase.ketang06;
public class ShangJia {
void print(Goods goods){
double price=goods.printPrice();
System.out.println(goods.getName()+"的价格是："+price+"元");
}
public static void main(String[] args) {
ShangJia shangJia=new ShangJia();
shangJia.print(new Tvs());
}
}
模拟选民投票demo1:
选民类：
package com.ibeifeng.javase.mianxiangduixiang;
public class Voters {
private static int count;
private static int[] id = {};//注意：对象每次初始化，必须为静态变量，数组存值才不会改变！！！
public int getCount() {
return count;
}
public void votecount() {
count++;
}
public int[] getId() {
return id;
}
public void setId(int id) {
boolean flag = true;
for (int i : getId()) {
if (id == i && id > 0) {
System.out.println("id号已存在！！");
flag = false;//通过设置标签判断数组中是否存在重复id号
break;
}
}
if (flag) {
int[] id0 = new int[getId().length + 1];
for (int i =0;i<=getId().length-1;i++) {
id0[i] = getId()[i];
}
id0[id0.length - 1] = id;
this.id=new int[id0.length];//注意：getId（）返回一个值，非赋值运算可以直接使用，但赋值运算必须用一个变量去接收它
for(int i=0;i程序入口：
package com.ibeifeng.javase.mianxiangduixiang;
import java.util.Arrays;
public class Vote {
void runMoni(){
for(int i=0;i<=110;i++){
if (i>=100){
break;
}
Voters voters=new Voters();
int len=voters.getId().length;
voters.setId(i);
if(voters.getId().length!=len){//通过数组设置前后长度判断选民是否重复投票
voters.votecount();
}else {
continue;//通过关键字continue设置是否跳过本次循环
}
// System.out.println(voters.getCount());
}
}
public static void main(String[] args) {
Vote vote=new Vote();
vote.runMoni();
Voters voters=new Voters();
System.out.println("投票总数： "+voters.getCount());
System.out.println(Arrays.toString(voters.getId()));
}
}
电子宠物系统练习demo2：
程序入口：
package com.ibeifeng.javase.zuoye06;
import java.util.Scanner;
public class Epet {
private int healthval = 60;
private String type;
private String name;
private String sextype;
private int qinmidu = 60;
/*使用封装实现电子宠物系统的企鹅类正确输入健康值
*保证健康值的有效性（0-100），否则取默认值60
* 保证亲密度的有效性（0-100），否则取默认值60*/
public int getHealthval() {
return healthval;
}
public void setHealthval(int healthval) {
if (healthval >= 1 && healthval <= 100) {
this.healthval = healthval;
setQinmidu(healthval);
} else {
System.out.print("健康值应该在0至100之间，默认值为：60.");
}
}
public String getType() {
return type;
}
public void setType(String type) {
if (!type.equals("1") && !type.equals("2")) {
System.out.println("请输入1/2选择宠物类型！！");
} else {
this.type = type;
if (type.equals("1")) {
System.out.print("请选择狗狗的品种：（1、泰迪犬 2、雪娜瑞犬）：");
} else {
System.out.print("请选择企鹅的性别：（1、Q仔 2、Q妹）：");
}
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSexType() {
return sextype;
}
public void setSexType(String sextype) {
if (!sextype.equals("1") && !sextype.equals("2")) {
System.out.println("请输入1/2选择宠物性别或品种！！");
} else if (sextype.equals("1") && type.equals("2")) {
this.sextype = "Q仔";
} else if (sextype.equals("2") && type.equals("2")) {
this.sextype = "Q妹";
} else if (sextype.equals("1") && type.equals("1")) {
this.sextype = "泰迪犬";
} else {
this.sextype = "雪娜瑞犬";
}
}
public int getQinmidu() {
return qinmidu;
}
public void setQinmidu(int healthval) {
this.qinmidu = healthval;
}
public void runpetshop() {
String flag = "y";
while (flag.equals("y")) {
System.out.print("欢迎您来到宠物店！\n请输入要领养宠物的名字：");
Scanner scan = new Scanner(System.in);
String name = scan.next();
setName(name);
System.out.print("请选择要领养的宠物类型：（1、狗狗 2、企鹅）：");
String type = scan.next();
setType(type);
String sex = scan.next();
setSexType(sex);
if (this.type.equals("1")) {
System.out.print("请输入狗狗的健康值（1-100之间）：");
} else {
System.out.print("请输入企鹅的健康值（1-100之间）：");
}
int healthvalue = scan.nextInt();
setHealthval(healthvalue);
if (this.type.equals("1")) {
Dog g = new Dog();
g.setName(this.name);
g.setSexType(this.sextype);
g.setHealthval(this.healthval);
g.setQinmidu(this.qinmidu);
System.out.println("\n宠物的自白：\n我的名字叫" + g.getName() + ",健康值是："
+ g.getHealthval() + ",和主人的亲密度是" + g.getQinmidu() + ",我是一只" + g.getType() + "。");
} else {
Penguin penguin = new Penguin();
penguin.setName(this.name);
penguin.setSexType(this.sextype);
penguin.setHealthval(this.healthval);
penguin.setQinmidu(this.qinmidu);
System.out.println("\n宠物的自白：\n我的名字叫" + penguin.getName() + ",健康值是："
+ penguin.getHealthval() + ",和主人的亲密度是" + penguin.getQinmidu() + ",我是一只" + penguin.getSexType() + "。");
}
System.out.println("是否结束程序？y/n:");
flag = scan.next();
while (!flag.equals("y") && !flag.equals("n")) {
System.out.println("请输入y/n:");
flag = scan.next();
}
}
}
public static void main(String[] args) {
Epet epet = new Epet();
epet.runpetshop();
}
}
/*参考输出：
欢迎您来到宠物店！
请输入要领养宠物的名字：欧欧
请选择要领养的宠物类型：（1、狗狗 2、企鹅）：1
请选择狗狗的品种：（1、泰迪犬 2、雪娜瑞犬）：2
请输入狗狗的健康值（1-100之间）：100
宠物的自白：
我的名字叫欧欧,健康值是：100,和主人的亲密度是100,我是一只雪娜瑞犬。
是否结束程序？y/n:
y
欢迎您来到宠物店！
请输入要领养宠物的名字：豆豆
请选择要领养的宠物类型：（1、狗狗 2、企鹅）：2
请选择企鹅的性别：（1、Q仔 2、Q妹）：2
请输入企鹅的健康值（1-100之间）：100
宠物的自白：
我的名字叫豆豆,健康值是：100,和主人的亲密度是100,我是一只Q妹。
是否结束程序？y/n:
n
*/
子类：狗类?
package com.ibeifeng.javase.zuoye06;
public class Dog extends Epet {
private int healthval = 60;
private String type;
private String name;
private String sex;
private int qinmidu = 60;
@Override
public void setSexType(String sex) {
this.sex = sex;
}
@Override
public String getType() {
return sex;
}
}
子类：企鹅类?
package com.ibeifeng.javase.zuoye06;
public class Penguin extends Epet{
private int healthval = 60;
private String type;
private String name;
private String sex;
private int qinmidu = 60;
@Override
public void setSexType(String sex) {
this.sex = sex;
}
@Override
public String getSexType() {
return sex;
}
}
接口：A implements B
接口中方法都是全局抽象方法，可以不需要abstract修饰，接口不能被实例化，类可以实现多个接口，接口中所有方法需要被重
写，接口中的变量默认都是全局静态常量public static final，接口中的方法，都是public修饰。
优点：可以被多继承，多实现，设计和实现分离，更自然的使用多态，更容易搭建程序框架，更容易更换实现。
抽象类利于代码复用，接口利于代码维护。
异常处理：
ctrl+h：查看类的所有子类。
ctrl+alt+t:多行try-catch
alt+enter:提示添加throw或try-catch异常
ctrl+o:重写父类方法
catch（形参类型：被捕获的异常类型），在异常代码中可以出现多个，异常范围大的放在最后，当出现多个catch捕获异常时，满足就近原则。
| try-catch |
| try-catch-catch |
| try-finally |
| try-catch-finally |
注意：若try中出现return，未出现异常，那么try-finally-return，出现异常则try-catch-finally(可以继续执行程序之后语句)；若catch中出现return则try-catch-finally-return
在catch语句中执行break或return依然会执行finally（无论代码是否正常运行finally都会执行），但若执行System.exit(0)或System.exit(1)中断jvm虚拟机，则不执行finally代码块
System.err.println（"加入用户自定义处理信息"）
| e.printStackTrace(); | 打印异常堆栈信息 |
| StringgerMessage(): | 返回异常信息描述字符串，是printStackTrace()输出信息的一部分 |
| Exception: | 异常层次结构的父类 |
| java.lang.ArithmeticException: | 算术异常 |
| Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: | 数组越界异常 |
| ClassNotFoundException: | 不能加载所需类 |
| illgalArgumentException: | 方法接受到非法参数（前台接收数据传入后台） |
| Exception in thread "main" java.lang.ClassCastException: | 对象强制类型转换异常 |
| Exception in thread "main" java.lang.NullPointerException: | 空指针异常 原因是由一个空值引用对象调用堆中变量造成 |
| Exception in thread "main"java.lang.NumberFormatException: | 数字格式化转换异常 |
java.lang.NoClassDefFoundError: 缺少jar包
object——>throwable——>Error:程序无法恢复的严重错误 ;Exception ——>checked：程序必须处理的异常;RuntimeException：正常情况下会正常编译，但遇到特殊情况下会抛出异常
throw：方法体内，抛出异常对象（可以是原生异常，也可以是自定义异常），只能抛出一个异常，需要和throws一起使用。
throws：方法体外，声明方法内抛出的异常，可以抛出多个异常。
自定义异常：1.创建一个类继承Exception,throwable,runtimeException;2.重写Exception中构造方法；3.实例化异常对象；4.使用throw抛出异常
异常链：A----->B(抛出异常) A中抛出的异常对象包含了B中异常对象的信息并且两个不是同一个异常对象
自定义异常：
package com.ibeifeng.javase.yichang;
public class ZidingyiException extends Exception {//重写父类方法：ctrl+o ；查看类的所有子类：ctrl+h
public ZidingyiException() {
super();
}
public ZidingyiException(String message) {
super(message);
}
public ZidingyiException(String message, Throwable cause) {
super(message, cause);
}
public ZidingyiException(Throwable cause) {
super(cause);
}
}
throw、throws：
package com.ibeifeng.javase.yichang;
public class PersonAge {
private int age;
private String name;
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//throws：方法体外，声明方法内抛出的异常，可以抛出多个异常
public void setAge(int age) throws ZidingyiException {
if (age < 100 && age > 0) {
this.age=age;
} else
//throw：方法体内，抛出异常对象（可以是原生异常，也可以是自定义异常），只能抛出一个异常，需要和throws一起使用。
throw new ZidingyiException("年龄必须在1-100之间！");
}
}
try-catch-finally
package com.ibeifeng.javase.yichang;
//查找类ctrl+n
public class AgeTest {
public static void main(String[] args) {
PersonAge personAge = new PersonAge();
personAge.setName("千寻");
try {//ctrl+alt+t:多行try-catch语句快捷键
personAge.setAge(0);
return;//注意：若出现异常，执行try-catch-finally并继续执行之后语句
} catch (ZidingyiException e) {
e.printStackTrace();
} finally {
System.out.println("主人公是：" + personAge.getName());
}
System.out.println("输出尾部！");
}
}
/*
com.ibeifeng.javase.yichang.ZidingyiException: 年龄必须在1-100之间！
at com.ibeifeng.javase.yichang.PersonAge.setAge(PersonAge.java:25)
at com.ibeifeng.javase.yichang.AgeTest.main(AgeTest.java:8)
主人公是：千寻
输出尾部！*/
package com.ibeifeng.javase.mianxiangduixiang;
import java.util.Scanner;
public class Keyichang {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = 1;
while (i >= 1 && i <= 3) {
System.out.print("请输入1-3任意数字：");
try {
i = scanner.nextInt();
switch (i) {
case 1:
System.out.println("C#编程");
break;
case 2:
System.out.println("Java");
break;
case 3:
System.out.println("Python");
break;
default:
System.out.println("注意仅能输入1-3任意数字！");
}
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
} finally {
System.out.println("欢迎提出建议！");
}
}
}
}
/*参考输出：
请输入1-3任意数字：1
C#编程
欢迎提出建议！
请输入1-3任意数字：2
Java
欢迎提出建议！
请输入1-3任意数字：3
Python
欢迎提出建议！
请输入1-3任意数字：a
java.util.InputMismatchException
at java.util.Scanner.throwFor(Scanner.java:864)
at java.util.Scanner.next(Scanner.java:1485)
at java.util.Scanner.nextInt(Scanner.java:2117)
at java.util.Scanner.nextInt(Scanner.java:2076)
at com.ibeifeng.javase.ketanglianxi07.Keyichang.main(Keyichang.java:12)
欢迎提出建议！*/
️
import java.util.*;
public class Cishu {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入一段字符！");//任意输入一段字符，输出字符及其个数
String next = s.next();
System.out.println(next);
HashMap hashMap = new HashMap();
char[] chars = next.toCharArray();
int num = 1;
for (int i = 0; i < chars.length; i++) {
if (hashMap.get(chars[i]) == null) {
for (int j = i + 1; j < chars.length; j++) {
if (chars[i] == chars[j]) {
num++;
}
}
hashMap.put(chars[i], num);
num = 1;
}
}
Set set = hashMap.keySet();
for (Object o : set) {
System.out.println(o + "\t\t" + hashMap.get(o));
}
}
}
/*参考输出：
*请输入一段字符！
yyyjjj****&&
yyyjjj****&&
& 2
y 3
j 3
* 4 */
package com.ibeifeng.javase.kaoshi;
import java.util.ArrayList;
import java.util.Collections;
public class Sort implements Comparable {
private String school;
private String area;
private double score;
private int xingji;
public Sort(String school, String area, double score, int xingji) {
this.school = school;
this.area = area;
this.score = score;
this.xingji = xingji;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public int getXingji() {
return xingji;
}
public void setXingji(int xingji) {
this.xingji = xingji;
}
public static void main(String[] args) {
Sort sort1 = new Sort("北京大学", "北京", 100, 7);
Sort sort2 = new Sort("清华大学", "北京", 98, 7);
Sort sort3 = new Sort("复旦大学", "上海", 82, 7);
Sort sort4 = new Sort("武汉大学", "湖北", 82, 6);
Sort sort5 = new Sort("浙江大学", "浙江", 82, 5);
Sort sort6 = new Sort("中国人民大学", "北京", 81.5, 5);
Sort sort7 = new Sort("上海交通大学", "上海", 81, 5);
Sort sort8 = new Sort("南京大学", "江苏", 80.9, 5);
Sort sort9 = new Sort("国防科技大学", "湖南", 80, 5);
Sort sort10 = new Sort("中山大学", "广东", 76, 4);
ArrayList arrayList = new ArrayList();
arrayList.add(sort1);
arrayList.add(sort2);
arrayList.add(sort3);
arrayList.add(sort4);
arrayList.add(sort5);
arrayList.add(sort6);
arrayList.add(sort7);
arrayList.add(sort8);
arrayList.add(sort9);
arrayList.add(sort10);
Collections.sort(arrayList);
System.out.println(" " + "学校名称\t 所在地区\t 总分\t 星级排名");
for (Sort s : arrayList) {
if (s.getSchool().toCharArray().length > 4) {
System.out.println(s.getSchool() + "\t\t" + s.getArea() + "\t\t" + s.getScore() + "\t\t" + s.getXingji());
} else {
System.out.println(" " + s.getSchool() + "\t\t" + s.getArea() + "\t\t" + s.getScore() + "\t\t" + s.getXingji());
}
}
}
@Override
public int compareTo(Sort o) {
Double score1 = this.getScore();
Double score2 = o.getScore();
Integer xingji1 = this.getXingji();
Integer xingji2 = o.getXingji();
// if (score1.compareTo(score2) != 0) {
// return -score1.compareTo(score2);
// } else
// return -xingji1.compareTo(xingji2);
/*三目运算：*/
return score1.compareTo(score2) != 0 ? -score1.compareTo(score2) : -xingji1.compareTo(xingji2);
}
}
/* 学校名称 所在地区 总分 星级排名
北京大学 北京 100.0 7
清华大学 北京 98.0 7
复旦大学 上海 82.0 7
武汉大学 湖北 82.0 6
浙江大学 浙江 82.0 5
中国人民大学 北京 81.5 5
上海交通大学 上海 81.0 5
南京大学 江苏 80.9 5
国防科技大学 湖南 80.0 5
中山大学 广东 76.0 4*/
不要忘记留下你学习的脚印 [点赞 + 收藏 + 评论]
一切看文章不点赞都是“耍流氓”，嘿嘿ヾ(◍°∇°◍)ﾉﾞ！开个玩笑，动一动你的小手，点赞就完事了，你每个人出一份力量(点赞 + 评论)就会让更多的学习者加入进来！非常感谢！￣ω￣=
核心编程
技术交流请加微信~~：
tchongyu