Java第三周学习完毕，写篇博客记录一下所学及所得。
1. 面向对象
学习内容：
- 上周：类的定义、对象的创建、属性的访问、方法的调用
- 方法的重载：规则及使用
- 类构造方法：规则、类创建过程
- 构造方法的重载：规则及使用、多参构造
- this关键字：①this.xxxx; ②this(xx,xxx);
- 多参级联访问
问题及错题：
- 多参级联访问：
定义Worker类，其属性有一个Address类，有员工的地址和邮编属性
public class Test {
public static void main(String[] args) {
Worker zhangsan = new Worker("zhangsan",25,2500,new Address());
//多参级联构造，先暂时为worker的addr属性建一个新对象
zhangsan.addr.address=("北京市海淀区清华园1号");//给worker对象的addr属性赋值
zhangsan.addr.zipCode = ("100084");
System.out.println(zhangsan.name
+ zhangsan.addr.address //从worker对象的addr属性取值
+ zhangsan.addr.zipCode);
}
}
class Worker{ //Worker类
String name ;
int age;
double salary;
Address addr; //addr属性为worker对象的地址和邮编
public Worker() {}
public Worker(String name , int age , double salary,Address addr) {
this.name = name ; //多参构造
this.age = age;
this.salary = salary;
this.addr =addr;
}
}
class Address{ //address类
String address ;
String zipCode ;
public Address() {}
public Address(String address , String zipCode) {
this.address = address ;//address类的多参构造
this.zipCode = zipCode ;
}
}
2. 对象的三大特性
学习内容：
封装 private：
使用：私有属性和公共方法
继承 extends：
1.继承的概念、要求，父类的选择
2.三大不可继承点：构造方法、private修饰的属性方法、修饰词限制
3.访问修饰符规则：private、default、protected、public在 本类、同包、非同包子类 的限制规定
4.方法的覆盖
5.super关键字的使用：super.xxx; super(xx,xxx);
6.继承中的对象创建：·创建子类对象必须先创建父类对象·
7.this 和 super 关键字对比
多态：
概念及语法
多态的使用场景：
1.使用父类作为 方法的形参，可以使用各种子类作为实参给父类形参，函数会调用对应子类的（覆盖）方法
2.使用父类作为 方法的返回值，将符合条件的子类作为返回值返回给掉用处，方法调用处可以调用子类覆盖过的方法
向上转型与向下转型：
1.向上转型：父类引用指向子类对象，对象只可使用父类的属性方法
2.向下转型：父类引用了子类对象，再强制转回子类本身类型
①语法及类型转换异常
②instanceof关键字
问题及错题：
- 将一组Animal数组中的Dog类挑选出来组成新数组，并将其遍历出来：
public class Q12 {
public static void main(String[] args) {
Animal[] as = new Animal[] {
new Dog("Pluto") ,
new Cat("Tom"),
new Dog("Snoopy") ,
new Cat("Garfield")};
//将所有狗类挑选出来，放在同一个数组
Dog[] dogs = getAllDog(as);
for(int i = 0 ; i<dogs.length; i++) { //遍历所有狗
System.out.println( dogs[i].getName() );
}
}
//挑狗的函数：
public static Dog[] getAllDog(Animal[] as) { //多态场景一：父类形参
int acount = 0;
//1.计数器，用来确定创建的狗数组的长度
for(int i = 0 ; i<as.length;i++) {
if(as[i] instanceof Dog) {
acount++;
}
}
Dog[] dogs = new Dog[acount];
//2.依计数器创建狗数组
int size = 0;
//3.有效长度确定数组的下标
//4.将狗挑出来放在狗数组
for(int i = 0 ; i<as.length;i++) {
if(as[i] instanceof Dog) { //符合要求，狗下标填值
dogs[size] = (Dog)as[i]; //这里使用到了强转，从Animal[]拆出来的元素默认为Animal，其真正类型为狗，从Animal强转回来
size++;//有效长度增加
}
}
return dogs;
}
}
class Animal{
private String name; //封装的属性
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public Animal(){}
public Animal(String str) {
setName(str);
}
}
class Dog extends Animal{
public Dog() {}
public Dog(String str) {
super(str);
}
}
class Cat extends Animal{
public Cat() {}
public Cat(String str) {
super(str);
}
}
- 继承与方法覆盖：
有图形类，能够计算图形的周长和面积
图形子类1 圆类 ，有半径属性
图形子类2 矩形，有长和宽属性
矩形子类长方形，有边长属性
import java.lang.Math;
public class Question15 {
public static void main(String[] args) {
Circle c1 = new Circle();
c1.radius = 3.0; //半径为3.0的圆
System.out.println(c1.area() + "\n" + c1.girth());
Square s1 = new Square();
s1.setSide(5.0); //边长为5.0的正方形
System.out.println(s1.area() + "\n" + s1.girth());
}
}
class Shape{ //祖父类：图形
public double area() { //能计算面积并返回
return 0;
}
public double girth() { //能计算周长并返回
return 0;
}
}
class Circle extends Shape{ //二叔类：圆形
double radius; //半径
public double area() { //面积
double s;
s = radius * radius * Math.PI;
return s;
}
public double girth() { //周长
double c;
c = 2 * Math.PI * radius;
return c;
}
}
class Rect extends Shape{ //父亲类：矩形
double length1; //长
double width; //宽
public double area() { //面积
double s;
s = length1 * width ;
return s;
}
public double girth() { //周长
double c;
c = length1 + width;
return 2*c;
}
}
class Square extends Rect{ //自己类：正方形
private double side; //私有边长
public void setSide(double side) { //set边长时一块set父类长宽
this.side = side;
this.length1 = side;
this.width = side;
}
public double getSide() {
return side;
}
//之后继承父类面积、周长
}
3. 三个修饰符
学习内容：
抽象 abstract:
抽象类、抽象方法
问题及错题：
- 将上面的计算图形周长面积的函数和方法抽象：
abstract class Shape{ //抽象——祖父类：图形
abstract public double area() ; //抽象方法——计算面积
abstract public double girth() ; //抽象方法——计算周长
}
