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() ; //抽象方法——计算周长
}