文章目录

1.封装：数据抽象
2.对象数组：先new
3.构造器：不写也有无参构造
- 3.1 数组工具类：return
- 3.2 冒泡排序应用：sort，temp
4.this/super/继承：多重，匿名对象
- 4.1 继承中构造方法：子类隐式调用父类空参构造
- 4.2 this/super内存图：new在堆中开辟一块空间，随后看类的成员变量，super小圈。StackOverflow
5.抽象：下定义。包/类/变量/方法名统称为标识符
- 5.1 work和project：super
- 5.2 Account类模拟账户：属性私有化，无参有参构造器，get/set，toString()
- 5.3 Account类子类CheckAccount类：无else
- 5.4 Book类：Book[ ] =，temp

1.封装：数据抽象

/*
1、封装的意义：（1）隐藏实现细节（2）安全
2、封装的类型：（1）属性的封装、方法的封装等（2）组件的封装（3）系统的封装
3、封装的实现，靠权限修饰符来控制可见的范围。权限修饰符：类：缺省或public，如果类前面有public，那么必须与源文件名相同属性：四种都可以。方法：四种都可以 4、属性的封装：大多数情况下，属性都是private。如果属性私有化了，我们会提供get/set方法get/set的标准写法：public void set属性名(数据类型 形参名){属性名 = 形参名;}public 属性的数据类型 get属性名(){return 属性名;}
5、方法的封装：大多数情况下，方法都是public
*/
public class Test10_Encapsulation{public static void main(String[] args){       Circle c1 = new Circle();  //1、创建对象                //c1.radius = 1.2;//错误的  c1.setRadius(1.2);    //2、为属性赋值    System.out.println("半径：" + c1.getRadius());}
}
class Circle{private double radius;//仅限与本类中访问   //radius属性的set方法，用于在其他类中修改radius的值public void setRadius(double r){if(r>0){//使得赋值可控radius = r;}}//radius属性的get方法，用于在其他类中获取radius的值public double getRadius(){return radius;}
}

2.对象数组：先new

/*
数组是用来存一组数，这组数可以是基本数据类型，也可以是引用数据类型。当我们数组中存储了一组对象时，那么我们称为对象数组。   int[] arr; 存了一组整数char[] arr; 存了一组单字符    String[] arr; 存了一组字符串对象Student[] arr; 存了一组学生对象
*/
class Test08_ObjectArray{public static void main(String[] args){//要用一个数组，存储5个圆对象，半径分别为1-5//(1)声明一个数组，数组的元素的类型是CircleCircle[] arr = new Circle[5];//这个new是创建数组对象       //(2)为数组的元素赋值for(int i=0; i<arr.length; i++){//元素：数组名[下标]//arr[i].radius = i+1;//java.lang.NullPointerException          arr[i] = new Circle();//创建圆对象arr[i].radius = i+1;}       //(3)遍历数组，打印每一个圆的信息for(int i=0; i<arr.length; i++){//现在的数组的元素arr[i]就是一个圆对象，既然是圆对象，就可以调用圆的属性和方法arr[i].printInfo();//System.out.println(arr[i]);}}
}
class Circle{double radius;         double getArea(){return 3.14 * radius * radius;}    void printInfo(){System.out.println("半径：" + radius + "，面积：" + getArea());}
}

/*
（1）声明一个学生类Student，包含姓名name和成绩score属性
（2）在测试类TestStudentArray中创建一个长度为3的学生数组
（3）从键盘输入为学生对象的姓名和成绩属性赋值
（4）遍历显示学生信息
（5）使用冒泡排序对数组按照学生成绩从低到高排序
（6）再次遍历显示学生信息
*/
class Test09_Exer3{public static void main(String[] args){//创建一个长度为3的学生数组Student[] all = new Student[3];       //从键盘输入为学生对象的姓名和成绩属性赋值java.util.Scanner input = new java.util.Scanner(System.in);for(int i=0; i<all.length; i++){System.out.println("请输入第" + (i+1) + "个学员的信息：");                       //创建这个学生对象all[i] = new Student();          System.out.print("姓名：");all[i].name = input.next();           System.out.print("成绩：");all[i].score = input.nextInt();}      //遍历显示学生信息for(int i=0; i<all.length; i++){//all[i].printInfo();System.out.println(all[i].getInfo());}     //使用冒泡排序对数组按照学生成绩从低到高排序for(int i=1; i<all.length; i++){//控制轮数 //从低到高，把大的往右移动/*当i=1, j=0,1  all[0]与all[1]  all[1]与all[2]当i=2，j=0    all[0]与all[1]all[j] 与 all[j+1]*/for(int j=0; j<all.length-i; j++){//all[j]是一个学生对象，不能比较大小//if(all[j] > all[j+1]){//二元运算符 '>' 的操作数类型错误if(all[j].score > all[j+1].score){//交换两个元素，不是交换两个人的成绩Student temp = all[j];//all[j]是一个Studentall[j] = all[j+1];all[j+1] = temp;}}         }       //遍历显示学生信息for(int i=0; i<all.length; i++){//all[i].printInfo();System.out.println(all[i].getInfo());}}
}
class Student{String name;int score;    void printInfo(){System.out.println("姓名：" + name + "，成绩：" + score);}String getInfo(){return "姓名：" + name + "，成绩：" + score;}
}

3.构造器：不写也有无参构造

 /*
类的第三个组成部分：构造器，也称为构造方法【因为它长的像方法且它编译后是一个实例初始化方法】1、构造器的作用：（1）构造对象，创建对象，和new一起使用，每次调用它就是在创建新的对象
（2）可以在创建对象的同时，给属性赋值2、构造器的特点：（1）所有类都有构造器
（2）如果一个类没有显式声明构造器，那么编译器将会自动生成一个默认的无参构造
（3）如果一个类显式声明了构造器，那么编译器将不会自动生成默认的无参构造了
（4）构造器的名称必须与类名相同
（5）构造器没有返回值类型，也不写void
（6）构造器可以重载3、构造器的语法结构【修饰符】 类名(){       }【修饰符】 类名(形参列表){        }   java.util.Scanner input = new java.util.Scanner(System.in);//调用的是有参构造int num = input.nextInt();//从键盘输入一个整数    java.util.Random rand = new java.util.Random();//调用的是无参构造int num = rand.nextInt(10);//产生一个[0,10)的整数
*/
class Test12_Constructor{public static void main(String[] args){//创建对象：类名 对象名 = new 类名();//Circle c = new Circle(); //这里Circle()就是构造器      Circle c = new Circle(1.2);//1.2给半径赋值，在创建对象的同时给属性赋值用的c.printInfo();     c.setRadius(2.5);//创建对象之后，修改属性值用的c.printInfo();      Circle c2 = new Circle();//先创建对象，不给半径赋值c2.setRadius(3.6);c2.printInfo();}
}
class Circle{private double radius; //double r：构造器的形参列表public Circle(double r){//有参构造radius = r;//给半径赋值}    public Circle(){//无参构造      }   public void printInfo(){System.out.println("半径：" + radius);}  public void setRadius(double r){radius = r;}
}

/*
声明学生类：（1）有属性：姓名，年龄，成绩，并且私有化，
（2）提供有参和无参构造
（3）提供公共的get/set。
（4）提供getInfo()方法，返回学生对象的信息
测试：（1）用有参和无参构造分别创建对象
（2）用set方法修改属性值
（3）用getInfo()返回学生信息
*/
class Test13_Exer5{public static void main(String[] args){//1、无参构造创建对象Student s1 = new Student();s1.setName("张三"); //s1.setName = "张三"; //错误的s1.setAge(23);s1.setScore(89);       System.out.println(s1.getInfo());   //2、有参构造创建对象Student s2 = new Student("李四",24, 34);System.out.println(s2.getInfo());s2.setScore(74); //修改成绩的值System.out.println(s2.getInfo());}
}
class Student{private String name;private int age;private double score; public Student(){       }public Student(String n, int a, double s){name = n;age = a;score = s;}  //提供公共的get/set。public void setName(String n){name = n;}public String getName(){return name;}public void setAge(int a){age = a;}public int getAge(){return age;}public void setScore(double s){score = s;}public double getScore(){return score;} public String getInfo(){return "姓名：" + name + "，年龄:" + age +"，成绩：" +score;}
}

3.1 数组工具类：return

class MyArrays{/* int  binarySearch(int[]  arr,  int  value)：
使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确*/public int binarySearch(int[]  arr,  int  value){  int left = 0;int right = arr.lenghth-1;int mid = (left + right)/2;      while(left<=right){if(arr[mid] == value){return mid;}else if(value > arr[mid]){left = mid + 1;}else if(value <arr[mid]){right = mid -1;}mid = (left + right)/2;}return -1;}   /* int  copy(int[] arr , int length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。*/public int[] copy(int[] arr, int length){     int[] newArr = new int[length];     //(1)创建新数组  for(int i =0; i<arr.length && i<newArr.length; i++){ //(2)复制元素newArr[i] = arr[i];}       return newArr;} //void sort(int[] arr)：可以给arr数组从小到大排序，用冒泡排序实现public void sort(int[] arr){for(int i=1; i<arr.length; i++){for(int j=0; j<arr.lenghth-i; j++){if(arr[j] > arr[j+1]){int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}
}

如下去掉return，结果为1。

3.2 冒泡排序应用：sort，temp

/*1、声明一个Employee员工类，包含属性：编号(id)、姓名(name)、薪资(salary)、年龄(age)包含方法：（1）void printInfo()：可以打印员工的详细信息（2）void setInfo(int  i, String n, double s, int a)：可以同时给id,name,salary,age赋值2、声明一个TestEmployee测试类（1）public static void main(String[] args)： 在main方法中，创建Employee[]数组，并创建5个员工对象放到数组中，并为员工对象的属性赋值（2）public static void print(Emplyee[] all)：遍历打印员工数组中的每个员工的详细信息，并在main中调用（3）public static void sort(Employee[] all)：将all员工数组按照《年龄》从高到低排序，并在main中调用测试（4）public static void addSalary(Employee[] all, double increament)：将all员工数组的每一个员工的《工资》增加increament，并在main中调试测试
*/
class Day08_Test05{public static void main(String[] args){Employee[] all = new Employee[5];all[0] = new Employee();all[0].setInfo(1,"张三",10000,23); all[1] = new Employee();all[1].setInfo(2,"李四",12000,23); all[2] = new Employee();all[2].setInfo(3,"王五",8000,18);all[3] = new Employee();all[3].setInfo(4,"赵六",6000,20);    all[4] = new Employee();all[4].setInfo(5,"钱七",15000,21);     print(all);sort(all);System.out.println("------------------------------------------");print(all); addSalary(all, 200);System.out.println("------------------------------------------");print(all);}public static void print(Employee[] all){for(int i=0; i<all.length; i++){all[i].printInfo();}}public static void sort(Employee[] all){for(int i=1; i<all.length; i++){for(int j=0; j<all.length-i; j++){//从高到低if(all[j].age < all[j+1].age){Employee temp = all[j];all[j] = all[j+1];all[j+1] = temp;}}}}public static void addSalary(Employee[] all, double increament){for(int i=0; i<all.length; i++){all[i].salary += increament;}}
}
class Employee{int id;String name;double salary;int age;void printInfo(){System.out.println("编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，年龄：" +age);}void setInfo(int  i, String n, double s, int a){id = i;name = n;salary = s;age = a;}
}

如下分别是sort年龄从高到低，addSalary增加200薪水

/*1、声明矩形类Rectangle（1）包含属性：长和宽，要求属性私有化（2）包含两个构造器：无参和有参（3）给每一个属性提供get/set方法（4）public double getArea()（5）public double getPerimeter()（6）提供getInfo()返回矩形对象的信息：例如：长：2，宽：3，面积：6，周长：102、测试类TestRectangle，编写Test07类，在main方法中（1）创建一个Rectangle[]数组，长度为5（2）并创建5个Rectangle的矩形对象，放到数组中，矩形的长和宽随机生成[0,10.0)范围内的值（3）遍历显示（4）按照面积从小到大排序（5）再次遍历显示
*/
class Day08_Test07{public static void main(String[] args){Rectangle[] arr  = new Rectangle[5];for(int i=0; i<arr.length; i++){arr[i] = new Rectangle();double d1 = Math.random()*10;double d2 = Math.random()*10;arr[i].setLength(d1>d2?d1:d2);        arr[i].setWidth(d1<=d2?d1:d2);      }       for(int i=0; i<arr.length; i++){System.out.println(arr[i].getInfo());}    System.out.println("------------------------");for(int i=1; i<arr.length; i++){ //冒泡for(int j=0; j<arr.length-i; j++){if(arr[j].getArea() > arr[j+1].getArea()){Rectangle temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}        for(int i=0; i<arr.length; i++){System.out.println(arr[i].getInfo());}}
}
class Rectangle{private double length;private double width; public Rectangle(){}public Rectangle(double chang, double kuan){length = chang;width = kuan;}public void setLength(double chang){length = chang;}public double getLength(){return length;}public void setWidth(double kuan){width = kuan;}public double getWidth(){return width;}   public double getArea(){return length * width;}public double getPerimeter(){return 2 * (length + width);}public String getInfo(){return "长：" + length + "，宽：" + width + "，面积：" + getArea() + "，周长：" + getPerimeter(); }
}

4.this/super/继承：多重，匿名对象

方法进栈，类属性（成员变量）进堆。

如下直接创建类（Demo01）时也创建好了包。

package com.itheima01.niming;
/*
*一个java文件可以定义多个类, 但是只有一个类是public(这个类要与文件同名)。
*几个类几个.class文件存在out文件夹中。
*匿名对象:就是没有名字的对象。只能一次性调用。格式简洁。
*/
public class Demo01 {public static void main(String[] args) {//对象有名字, 名字就是p (p记住了对象的内存地址) -> p叫变量名或引用Person p = new Person("张三",18);System.out.println(p.name); // 张三//new Person("张三",18); // 匿名对象new Person(); // 匿名对象 : 没有变量记住这个对象的地址new Person().name = "李四";// 0x0001System.out.println(new Person().name);//又new了，0x0002 : nullPerson p3 = new Person();p3.study(); // null正在学习//如下等于上面两行，格式比较简洁new Person().study(); // null正在学习}
}
class Person{String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;}public void study(){System.out.println(name + "正在学习");}
}

如下将硬盘上.class文件（class Person…）加载进内存中，p存的是内存地址。

package com.itheima02.inherit;public class Demo01 {  // field (字段, 属性)public static void main(String[] args) {Zi  zi = new Zi();zi.name = "张三";zi.age = 18;zi.kongFu();}
}
class Fu{String name;int age;private String Cat; // 私有: 外部不可访问，不能继承public Fu(){ // 构造: 方法名必须与类名一致，所以不能继承}public void kongFu(){System.out.println(age +"岁" + name + "正在联系辟邪剑~");}
}
class Zi extends Fu{public Zi(){}
}

package com.itheima03.filed;
import com.sun.org.apache.xpath.internal.SourceTree;
/*
*  继承后, 子类存在与父类同名的属性：1. 结论: 那么在子类访问中 遵循就近原则。
*   2. 直接访问父类中的属性: 关键字super，父类(超类 super class, 基类)。一般不会出现子父类同名属性。
*/
public class FiledDemo {public static void main(String[] args) {Zi zi = new Zi();        zi.speak(); //子类对象 可以直接调用父类的属性和方法}
}
class Fu{String name = "张三";
}
class Zi extends Fu{String nickName = "大帅哥";String name = "李四";/* public Zi(String name){ //同名成员和局部变量(构造方法中出现)this.name = name;}*/    public void speak(){  //可以在子类的内部直接调用String name = "王五";System.out.println("我的局部名字叫:" + name); //王五System.out.println("我的成员名字叫:" + this.name); //李四System.out.println("我的父类名字叫:" + super.name); //张三System.out.println("我的昵称叫:" + nickName); //大帅哥}
}

package com.itheima04.method;
/*
*   继承中, 子父类存在相同的方法  -> 方法重写
*       1. 方法重载(overload)
*           一个类中,存在方法名相同,但是参数列表不同(类型,个数,顺序)的方法
*       2. 方法重写(overried)
*           基于继承关系 : 子类中定义与父类完全相同的方法(方法名,参数列表,返回值类型都同)
*           效果 : 子类对象都是直接调用子类重写后的方法
*   注解: @Override(标记)作用: 在源码编译时,检测此方法是否是重写方法,如果不是,就会编译报错。
*/
public class MethodDemo {public static void main(String[] args) {Zi zi = new Zi();zi.show(); // zi:showzi.speak(); // zi:show  zi:speak}
}
class Fu{public void show(){System.out.println("fu:show");}
}
class Zi extends Fu{public void speak(){show(); //可以，调用子类重写的方法System.out.println("zi:speak");}@Override //可以不写public void show(){System.out.println("zi:show");}
}

package com.itheima04.method;public class PhoneDemo {public static void main(String[] args) {HuaWei hw = new HuaWei();hw.call(); //打电话 来电显示 视频通话System.out.println("------------------------------");                BigBrother bb = new BigBrother();bb.call(); //打电话}
}
class BigBrother{public void call(){System.out.println("打电话");//若有10000行}
}
class HuaWei extends BigBrother{ // 小技巧: 直接在子类中写方法名,提示重写方法同名方法@Overridepublic void call() {super.call();
// 调用父类方法: 保留旧功能。如果直接写成call()就近原则自己调用自己，死循环调用StackOverflowError，不叫递归（递归必须有结束条件）//扩展System.out.println("来电提示");System.out.println("视频通话");}
}

4.1 继承中构造方法：子类隐式调用父类空参构造

默认构造函数是编译器隐含提供的一个无参构造函数，仅当类中没有定义任何构造函数时才有效。

如下super/this不能在普通方法中调用。

package com.itheima05.constructor;
/*
*  方法重写：1. 父类中的private方法是不能重写的 (private方法/构造方法不能继承,也就不能重写)
*           2. 在子类中重写的方法权限 不能小于 父类中的方法 (大于或等于 才可以，原因: 多态)
*              private < default(默认,不写) < protected < public
*
*  继承关系中的构造方法特点 (构造器): 1. 构造方法不能继承
*       2.定理: 子类的构造必须调用父类的构造!!（要么直接调用，要么间接调用），重要！！！！！！！
*           <1> 子类的空参构造,隐式调用父类的空参构造
*           <2> 如果父类没有空参构造, 必须 手动调用其他父类构造
*/
public class Demo01 {public static void main(String[] args) {new Zi(); //子类构造}
}
class Fu{String name;int  age;public Fu(String name,int age){this.name = name;this.age = age;}
}
class Zi extends Fu{int number;/* 如下方法可以，但不够面向对象，对象有封装性public Zi(String name,int age,int number){super.name = name;super.age = age;this.number = number;}*/public Zi(String name,int age,int number){super(name,age); //让父类的构造给自己的属性赋值，尽量不去打扰你的属性，通过方法访问this.number = number; //左成员=右局部，类属性初始化}public Zi(){super(null,0);System.out.println("子类构造");}public Zi(String name,int age){this(name,age,0); //0是默认值，间接调用父类}
}//11111111111111111111111111111111111111111111111111111111111111111
class F{String name;public F(String name){this.name = name;}
}
class Z extends F{public Z(){ //父类没有无参构造让子类隐式调用，就手动调用父类有参构造super(null); //null指name}
}

如下this()调用下面public Zi()无参构造，至少要有一个调用父类。没有一个子类能执行完。

4.2 this/super内存图：new在堆中开辟一块空间，随后看类的成员变量，super小圈。StackOverflow

如下先红线将name赋为张三，再橙线。

5.抽象：下定义。包/类/变量/方法名统称为标识符

package com.itheima08.abstractd;
/*
*   抽象: 1.没有方法体的方法,设置为抽象方法  -> 关键字abstract
*         2.如果一个类拥有抽象方法, 必须声明为抽象类
*/
public class AbstractDemo {public static void main(String[] args) {Dog d = new Dog();d.eat(); //狗吃骨头}
}
abstract class Animal{  //父类: 所有子类的共性抽取String name;abstract void eat();abstract void run();
}
/*
*  如下若子类报错: 方案A: 把当前类 继续 声明为抽象类
*         方案B: 重写父类中所有的抽象方法
*/
class Dog extends Animal{@Overridevoid eat() {System.out.println("狗吃骨头");}    @Overridepublic void run() {System.out.println("狗在欢快的跑");}
}

package com.itheima08.abstractd;
/*
*   抽象的语法细节：1. 拥有抽象方法的类 必须是抽象类,不服气可以方法重写
*       2. 抽象类不一定要拥有抽象方法
*       3. 抽象类不能实例化(不能new对象)（调用方法时没有方法体）
*       4. 抽象类也有构造方法（子类一定调用父类构造）  -> 接口和抽象类 像
*/
public class AbstractDemo02 {public static void main(String[] args) {B b = new B(); // A的构造}
}
abstract class A{public A(){System.out.println("A的构造");}abstract void eat(); //强制要求子类重写，如果子类不重写，子类定义为抽象类，又不好创建对象public void speak(){};
}
class B extends A{@Overridevoid eat() {}
}

5.1 work和project：super

package com.itheima09.example;public abstract class Employee { //信息太少的员工，abstract不让它实例化，下定义private String name;private int age;public Employee(String name,int age){this.name = name;this.age = age;}public abstract  void work();public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.itheima09.example;public abstract class Development extends Employee {    public Development(String name, int age) { super(name, age);}@Overridepublic void work() {System.out.println("正在做研发工作");}public abstract void project(); //只知道研发项目，不知道研发哪个具体项目
}

如下都是继承Development类。

package com.itheima09.example;public class JavaEE extends Development {public JavaEE(String name, int age) {super(name, age);}@Overridepublic void project() {System.out.println(getName() + "javaee项目研发中"); //不能直接写name（私有化）}
}

package com.itheima09.example;public class Android extends Development {public Android(String name, int age) {super(name, age);}@Overridepublic void project() {System.out.println("正在研发安卓项目");}
}

package com.itheima09.example;public class Demo {public static void main(String[] args) {JavaEE ee = new JavaEE("张三", 18);  //Android也一样可实例化ee.work();ee.project();}
}

5.2 Account类模拟账户：属性私有化，无参有参构造器，get/set，toString()

package com.atguigu.test02.exer;
/** 该类包括的属性：账号id，余额balance，年利率annualInterestRate；（类的属性也叫成员变量或全局变量）。* * 包含的方法：访问器方法（getter和setter方法），返回月利率的方法getMonthlyInterest()，*             取款方法withdraw()，存款方法deposit()。*/
public class Account {private String id;//银行账号，身份证号，邮编，手机号，这种数字比较长的，又不进行数学运算，一般字符串存储private double balance;private double annualInterestRate;public Account() {super();}public Account(String id, double balance, double annualInterestRate) {super();this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;}public String getId() {return id;}public void setId(String id) {this.id = id;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public double getAnnualInterestRate() {return annualInterestRate;}public void setAnnualInterestRate(double annualInterestRate) {this.annualInterestRate = annualInterestRate;}    //1111111111111111111111111111111111111111111111111111111111111111111111111111111 /** 返回月利率的方法getMonthlyInterest()，* 取款方法withdraw()，存款方法deposit()。*/public double getMonthlyInterest(){       return annualInterestRate / 12;  //月利率 = 年利率 / 12;}    public void withdraw(double amount){if(amount < 0){System.out.println("非法参数");return ;//结束当前方法}        if(amount > balance){System.out.println("余额不足");}else{balance -= amount;}}    public void deposit(double amount){if(amount < 0){System.out.println("非法参数");return ;//结束当前方法}balance += amount;}
}

package com.atguigu.test02.exer;
/** 写一个测试类TestAccount：在用户程序中，创建一个账号为11223344、余额为20000、年利率4.5%的Account对象。* 使用withdraw方法提款30000元，并打印余额。* 再使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率。*/
public class TestAccount {public static void main(String[] args) {//创建一个账号为11223344、余额为20000、年利率4.5%的Account对象。Account account = new Account("11223344", 20000, 4.5/100);    //使用withdraw方法提款30000元，并打印余额。account.withdraw(30000);System.out.println("余额：" + account.getBalance());//再使用withdraw方法提款2500元account.withdraw(2500);System.out.println("余额：" + account.getBalance());//deposit方法存款3000元account.deposit(3000);System.out.println("余额：" + account.getBalance());System.out.println("月利率：" + account.getMonthlyInterest()*100+"%");}
}

5.3 Account类子类CheckAccount类：无else

package com.atguigu.test02.exer;
/*Account类子类CheckAccount代表可透支的账户，该账户中定义一个 属性overdraft 代表可透支限额，在CheckAccount类中重写withdraw方法*/
public class CheckAccount extends Account {private double overdraft;public CheckAccount() {}public CheckAccount(String id, double balance, double annualInterestRate,double overdraft) {super(id, balance, annualInterestRate);this.overdraft = overdraft;}public double getOverdraft() {return overdraft;}public void setOverdraft(double overdraft) {this.overdraft = overdraft;}@Overridepublic void withdraw(double amount) {if(amount < 0){System.out.println("非法参数");return ;//结束当前方法}//if(amount > 余额 + 可透支额度)，balance是父类私有的，无法直接使用//if(amount > balance +overdraft){if(amount > getBalance() +overdraft){System.out.println("超过可透支的额度");}else if(amount > getBalance()){//需要透支//(1)计算需要透支多少double d = amount - getBalance();//(2)修改可透支的额度overdraft -= d;//(3)把余额修改为0setBalance(0);         }else if(amount <= getBalance()){//不需要透支//balance是父类私有的，无法直接使用//balance -= amount;//修改属性，可以用set方法setBalance(getBalance() - amount);}}
}

package com.atguigu.test02.exer;public class TestCheckAccount { // 用户程序测试CheckAccount类public static void main(String[] args) {//创建一个账号为11223344、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。CheckAccount c = new CheckAccount("11223344", 20000, 4.5/100, 5000);   //使用withdraw方法提款5000元，并打印账户余额和可透支额。c.withdraw(5000);System.out.println("余额：" + c.getBalance());//这个方法是从父类继承的System.out.println("可透支额度：" + c.getOverdraft());System.out.println();//再使用withdraw方法提款18000元，并打印账户余额和可透支额。c.withdraw(18000);System.out.println("余额：" + c.getBalance());//这个方法是从父类继承的System.out.println("可透支额度：" + c.getOverdraft());System.out.println();//再使用withdraw方法提款3000元，并打印账户余额和可透支额。c.withdraw(3000);System.out.println("余额：" + c.getBalance());//这个方法是从父类继承的System.out.println("可透支额度：" + c.getOverdraft());System.out.println();//再使用deposit方法存款1000元，并打印账户余额和可透支额c.deposit(1000);System.out.println("余额：" + c.getBalance());//这个方法是从父类继承的System.out.println("可透支额度：" + c.getOverdraft());System.out.println();//再使用withdraw方法提款3000元，并打印账户余额和可透支额c.withdraw(3000);System.out.println("余额：" + c.getBalance());//这个方法是从父类继承的System.out.println("可透支额度：" + c.getOverdraft());System.out.println();}
}

5.4 Book类：Book[ ] =，temp

package com.atguigu.homework.test05;public class Book {private Integer id;private String title;private String author;private double price;private Integer sales;private Integer stock;private String imgPath = "static/img/default.jpg";public Book() {super(); //object类}public Book(Integer id, String title, String author, double price, Integer sales, Integer stock, String imgPath) {super();this.id = id;this.title = title;this.author = author;this.price = price;this.sales = sales;this.stock = stock;this.imgPath = imgPath;}public Book(Integer id, String title, String author, double price, Integer sales, Integer stock) {super();this.id = id;this.title = title;this.author = author;this.price = price;this.sales = sales;this.stock = stock;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public Integer getSales() {return sales;}public void setSales(Integer sales) {this.sales = sales;}public Integer getStock() {return stock;}public void setStock(Integer stock) {this.stock = stock;}public String getImgPath() {return imgPath;}public void setImgPath(String imgPath) {this.imgPath = imgPath;}public String getInfo(){return id + "\t" + title +"\t\t" + author  + "\t" + price + "\t" + sales + "\t" + stock + "\t" + imgPath;}
}

package com.atguigu.homework.test05;public class Test05 {public static void main(String[] args) {Book[] all = new Book[4];  //数组中存放book类，数组名为all     all[0] = new Book(1, "《西游记》", "吴承恩", 88, 100, 200);all[1] = new Book(2, "《红楼梦》", "曹雪芹", 56, 800, 100);all[2] = new Book(3, "《三国演义》", "罗贯中", 77, 500, 800);all[3] = new Book(4, "《水浒传》", "施耐庵", 66, 54, 600,"static/img/shui.jpg");        for (int i = 0; i < all.length; i++) {System.out.println(all[i].getInfo());}for (int i = 1; i < all.length; i++) {      //冒泡排序for (int j = 0; j < all.length-i; j++) {if(all[j].getSales() < all[j+1].getSales()){Book temp = all[j];all[j] = all[j+1];all[j+1] = temp;}}}       System.out.println("----------------------------------");System.out.println("编号\t书名\t\t作者\t价格\t销量\t库存量\t图片");for (int i = 0; i < all.length; i++) {System.out.println(all[i].getInfo());}}
}

【Java3】封装，对象数组，构造器，this/super/继承，抽象相关推荐

前端ajax封装对象数组，后台的取法
在做项目的时候,突然发现有一个问题困扰很久,就是前端把封装成list型的JSON对象,后台要怎么获取. 其实这个时候是需要前端将封装的数据进行"user": JSON.string ...
java封装对象数组_java解析JSON对象和封装对象的示例
在本例中java解析JSON对象使用的是org.json,因此,如果各位想测试我的代码,请先确保有java.json.jar包,否则,就需要去网上下载这个jar包,然后才可以正常使用本代码. 本例的功 ...
java继承数组实例_【Java】理解封装、继承、多态和对象数组的综合实例（简易的租车系统，附代码）...
一.Drive.java(汽车类 - 父类) package Z_CarManger; import java.io.ObjectInputStream.GetField; public abstra ...
lrc格式歌词格式化处理函数封装，返回对象数组
lrc格式歌词格式化处理函数封装,返回对象数组函数 /*** lrc格式歌词格式化 * @param { STRING } lrc lrc格式歌词* @return { ARRAY } 返回对象数组 ...
C++远征之封装篇——对象数组，对象成员
一.对象数组 (1)如下,delet [ ]p时,会调用三次析构函数 (2)细节实例化对象数组时,每一个对象的构造函数都会被执行. 销毁对象数组时,每一个对象的析构函数都会被执行. 二.对象成员 1 ...
js 数组移除指定元素【函数封装】（含对象数组移除指定元素）
普通数组移除指定元素 // 普通数组移除指定元素 function removeItem(arr, item) {let targetIndex = arr.findIndex((itemTemp) ...
ES6对象(3)：类的继承
1.继承的概念如果两个类A和B,如果可以描述为:B是A(例如:猫是动物,轿车是汽车,男人是人),则A和B形成继承关系.如果B是A,则: B继承自A A派生B B是A的子类 A是B的父类如果A是B的 ...
java list数组排序_浅谈对象数组或list排序及Collections排序原理
常需要对list进行排序,小到List,大到对自定义的类进行排序.不需要自行归并或堆排序.简单实现一个接口即可. 本文先会介绍利用Collections对List进行排序,继而讲到Collection ...
【java笔记】类与对象（定义，创建，使用，标准的类，对象数组）
面向对象的特征: 封装,继承,多态类:一组相关属性(数据成员)和行为(成员方法)的集合.抽象出事物的属性和行为来描述事物. 对象:一类事物的具体体现. 类和对象的关系: 类的定义: 例:定义一个学生 ...

【Java3】封装，对象数组，构造器，this/super/继承，抽象