文章目录
- 0 开发工具
- 1. 对象和类、三大特性
- 2. 成员/实例变量和实例变量(this关键字)
- 3. 方法重载overload
- 4. 构造方法和this关键字
- 5. 继承
- 6. 访问修饰符
- 7. 方法重写
- 8. 继承下的构造执行
- 9. 多态
- 9.1 向上转型
- 9.2 向下转型
- 9.3 多态的应用
0 开发工具
Maven是进行包管理的工具,只需要声明一些配置,程序就可以自动下载所依赖的包。其配置文件在本机电脑~\.m2\settings.xml
中,settings.xml里面声明了依赖包存放的位置,也可以在里面声明下载依赖包的国内镜像地址。
idea中自带了jdk,无需额外安装。
Git可用来进行版本控制
1. 对象和类、三大特性
面向对象的思想object oriented programming:一切皆对象,对象由属性和方法构成。
类相当于一个模板,对象是由类创建出来的,每个对象都是类的一个实例,创建对象的过程也称为实例化。
封装:把一些对象的共同属性、方法抽象出来,合理的封装,抽象成类。
继承:子类享有父类的属性和方法,并且还存在一定的属性和方法的扩展
多态:有两种意义的多态。一种是操作名称的多态,即有多个操作具有相同的名字,但这些操作所接收的参数类型必须不同。 另一种多态是和继承有关的多态,是指同一个操作被不同类型对象调用时可能产生不同的行为。
2. 成员/实例变量和实例变量(this关键字)
成员变量也叫实例变量。
// 该例子展示了实例/成员变量、局部变量的作用范围
// 以及this关键字的使用:this指向当前对象
public class Dog {
String name;
public Dog(){ // 构造方法
name="汪汪";
}
public void eat(){
String name="局部变量汪汪";
System.out.println(name+"在吃东西");//name=局部变量汪汪
System.out.println(this.name+"在吃东西");//name=汪汪
}
public void sleep(){
System.out.println(name+"在睡觉");//name=汪汪
}
public String getName() {
return name; //name=汪汪
}
}
3. 方法重载overload
方法重载overload:一个类中定义多个具有相同名字的方法,具体执行哪个,由传入的参数决定。即方法名字相同,参数列表不同(类型、个数、顺序),与返回值类型、访问修饰符无关。
System.out.println();是一个经典的重载方法。
//方法重载举例
public class ClassTest {
public void test(int a){}
public void test(String a){}
public void test(int a,String b){}
public void test(String a,int b){}
}
4. 构造方法和this关键字
构造方法:类中的特殊方法,主要用于创建对象。
- 名称与类名相同
- 没有返回类型
- 创建对象时,出发构造方法
- 编译器默认执行一个无参的构造方法
- 构造方法也可以重载,遵循重载规则
public class ThisTest {
public static void main(String[] args) {
ThisDog dog=new ThisDog("汪汪",5,"公");
System.out.println(dog.name+"---"+dog.age+"---"+dog.sex);
}
}
public class ThisDog {
String name;
int age;
String sex;
public ThisDog(String name,int age){
this.name=name;
this.age=age;
}
public ThisDog(String name,int age,String sex){
this(name,age); //this调用重载的构造方法只能放在第一行
this.sex=sex;
}
}
5. 继承
语法:class子类 extends 父类{ } //定义子类时,显式继承父类。所有的类默认都继承Object
应用:子类可以使用父类中的属性和方法,也可定义自己独有的属性和方法。
优势:提高了代码的复用性和可扩展性。
特点:单继承(一个子类只能有一个直接父类);多重继承(类之间可以多级继承,如C类可以继承A类、B类中所有的属性和方法)
注意:父类的私有属性可以被继承但不能被直接访问(可借助其他工具观察内存分布,可知父类的私有属性可以被继承。父类的私有属性可通过get、set方法访问)。
当父类和子类具有相同的属性时,使用super和this关键字区分。
父类的私有属性可通过get、set方法访问
public class A {
private int a;
public void setA(int a) {
this.a = a;
}
public int getA() {
return a;
}
public void show() {
System.out.println("父类的show方法");
}
}
public class B extends A{
public B(){
setA(1);
}
public void show(){
System.out.println(getA()+" 子类的show方法");
}
}
public class Test {
public static void main(String[] args) {
B b=new B();
b.show();
}
}
//输出: 1 子类的show方法
6. 访问修饰符
Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
- default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
- private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
- public : 对所有类可见。使用对象:类、接口、变量、方法
- protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
我们可以通过以下表来说明访问权限:
默认访问修饰符-不使用任何关键字
如果在类、变量、方法或构造函数的定义中没有指定任何访问修饰符,那么它们就默认具有默认访问修饰符。
默认访问修饰符的访问级别是包级别(package-level),即只能被同一包中的其他类访问。
7. 方法重写
前提A是父类,B extends A
有以下规则和特点:
- 子类方法的访问权限可以比父类大
- 子类方法的返回值类型可以和父类一致,也可以是父类返回类型的子类
- 方法名一定要完全一样
- 参数列表也必须和父类完全一样(否则就成方法重载了)
- 子类重写父方法后,优先执行子类方法。若想要执行父类中被重写 的方法,使用super关键字
//父类A中的show方法
protected A show() {
System.out.println("父类的show方法");
return null;
}
//子类B中的show方法,B extends A,public > protected,B < A
public B show(){
super.show();
System.out.println("子类的show方法");
return null;
}
public class Test {
public static void main(String[] args) {
B b=new B();
b.show();
}
}
/*输出:
父类的show方法
子类的show方法
*/
8. 继承下的构造执行
要想构造子类,必先调用父类构造方法,但并未构建一个父类对象,构建的是子类对象
// 无参构造方法
package example05;
public class Test {
public static void main(String[] args) {
new C();
}
}
class A{
public A(){
System.out.println("A的构造方法");
}
}
class B extends A{
public B(){
System.out.println("B的构造方法");
}
}
class C extends B{
public C(){
System.out.println("C的构造方法");
}
}
//output:
//A的构造方法
//B的构造方法
//C的构造方法
要想构造子类,必先调用父类构造方法,但并未构建一个父类对象,构建的是子类对象。其空间分布如下:
其判断具体见下面代码中的注释掉的输出,均为true。
一个子类对象可以是一个父类类型,但一个父类对象不能是一个子类类型。如b是B的一个对象,c是C的一个对象,b instanceof C=false,c instanceof B=true
// System.out.println(this instanceof B);// true,一个子类类型可以是一个父类类型
// System.out.println(this instanceof C);// true
// 有参构造方法
package example06;
public class Test {
public static void main(String[] args) {
C c=new C(7,8,9);
System.out.println(c.a+"---"+c.b+"---"+c.c);
}
}
class A{
int a=1;
public A(int a){
this.a=a;
System.out.println("A的构造方法");
}
}
class B extends A{
int b=2;
public B(int a,int b){
super(a);
this.b=b;
System.out.println("B的构造方法");
// System.out.println(this instanceof B);// true
// System.out.println(this instanceof C);// true
}
}
class C extends B{
int c=3;
public C(int a,int b,int c){
super(a,b);
this.c=c;
System.out.println("C的构造方法");
}
}
//输出
//A的构造方法
//B的构造方法
//C的构造方法
//7---8---9
9. 多态
以下所举例子,均以A是父类,B extends A,C extends B为前提。
9.1 向上转型
父类引用指向子类对象,从而形成多态。
父类引用仅可调用父类所声明的属性和方法,不可调用子类独有的属性和方法。
A a=new B();
A a
是父类引用(引用类型),new B()
产生了一个子类对象(对象类型),a只能调用A中的方法/属性,不能调用B中的方法/属性。也就是a.属性/方法()
必须在类A中存在。
若子类B没有重写A的show方法,输出父类A的show方法。若调用a.showB()
会报错,因为父类A中并没有showB方法
package example06;
public class Test {
public static void main(String[] args) {
A a=new B();
a.show();
// a.showB(); //报错
}
}
class A{
public void show(){
System.out.println("父类A的show方法");
}
}
class B extends A{
public void show(){
System.out.println("子类B的show方法");
}
public void showB(){
System.out.println("子类B的showB方法");
}
}
//输出:子类B的show方法
9.2 向下转型
将父类引用中的真实子类对象,强制转换为子类本身对象,称为向下转型。
A a=new B();
B b=(B) a;//强制类型转换
向下转型前,应判断引用中的对象的真实类型(使用instanceof
来判断),保证类型转换的正确性。
9.3 多态的应用
应用一:使用父类作为方法形参实现多态,使方法参数的类型更广泛。
应用二:使用父类作为方法返回值实现多态,使方法可以返回不同子类对象。
package example08;
public class Person {
public void feed(Pet pet){//多态的应用一,Pet作为方法形参
pet.eat();
}
public Pet getPet(String type){//多态的应用二,返回的是Pet
if(type.equals("dog")){
return new Dog();
}
else{
return new Cat();
}
}
public static void main(String[] args) {
Person person=new Person();
Pet pet=person.getPet("dog");
person.feed(pet);//多态的应用二
person.feed(new Cat());//多态的应用一,可以改成new别的,如Dog
}
}
class Pet{
public void eat(){
System.out.println("在吃东西");
}
}
class Dog extends Pet{
public void eat(){
System.out.println("狗狗在啃骨头");
}
}
class Cat extends Pet{
public void eat(){
System.out.println("猫咪在吃鱼");
}
}