JAVA基础10
抽象类
用abstract 修饰的类:
当我们父类的方法不需要方法体时,我们可以将我们的方法修饰成抽象的
抽象方法格式:
abstract 修饰符 返回值类型 方法名(参数列表);
抽象类的定义格式:
abstract class 类名{}
注意事项:
-
抽象类中可以没有抽象方法,有抽向方法的类一定是抽象类
-
抽象类不能创建对象,需要使用子类向上转型
3.抽象类本身无意义,所以我们应该使用一个类去继承它,然后重写里面所有的
抽象方法,或者,这个子类本身也得是一个抽象类
-
抽象类有构造方法,本身无意义,但是可以给子类对象初始化,因为继承关系中,子类对象想要创建成功,必须到父类构造中走一圈
-
abstract 不能和final共存,因为被final修饰的类不能被继承而abstract修饰的类必须被继承
如果想要使用抽象类中的对象,可以使用抽象类多态的形式
-
/** - 定义一个抽象类形状(Shape)，包含两个方法，求周长和面积(抽象方法) 定义一个类长方形，实现抽象类中的方法 (长,宽) (构造方法) 定义一个类圆，实现抽象类中的方法 (半径) (构造方法) 在测试类中测试 创建一个长方形和圆,分别求周长和面积 创建一个方法,既可以求圆的周长面积,也可以求长方形的周长和面积 */ public class AbstractTest2 { public static void main(String[] args) { Shape r = new Rect(20,10); /*System.out.println(r.getPrimeter()); System.out.println(r.getArea());*/ Shape c = new Circle(4); /*System.out.println(c.getPrimeter()); System.out.println(c.getArea());*/ print(r); print(c); } public static void print(Shape s) { System.out.println("周长为:" + s.getPrimeter()); System.out.println("面积为: "+ s.getArea()); } } abstract class Shape{ abstract public double getPrimeter(); abstract public double getArea(); } class Rect extends Shape{ double length; double width; public Rect() {} public Rect(double length,double width) { this.length = length; this.width = width; } public double getPrimeter() { return 2*(length+width); } public double getArea() { return length*width; } } class Circle extends Shape{ public static final double PI = 3.14; double r; public Circle() {} public Circle(double r) { this.r = r; } public double getPrimeter() { return 2*PI*r; } public double getArea() { return PI*r*r; } }
继承关系和组合关系:
案例: 定义一个Person类,里面包含,姓名,年龄,性别和手机(品牌,型号,价格,颜色):
创建一个对象: 张三,18,男,手机(华为,p20,1888,“黑色”)
public class PersonTest {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
p.setAge(18);
p.setGender('男');
Mobile m = new Mobile();
m.setBrand("华为");
m.setType("p20");
m.setColor("黑色");
m.setPrice(1888);
p.setMobile(m);
p.show();
Person p2 = new Person("李四",29,'女',new Mobile("小米","note8","白色",1000));
p2.show();
}
}
/**
- 继承: is a Teacher is a Person
- 组合: has a Person has a Mobile
- 聚合: has a
- Person 和 Mobile 关系就叫做组合关系
*/
class Person{
private String name;
private int age;
private char gender;
private Mobile mobile;//组合
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;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public Mobile getMobile() {
return mobile;
}
public void setMobile(Mobile mobile) {
this.mobile = mobile;
}
public Person() {
super();
}
public Person(String name, int age, char gender, Mobile mobile) {
super();
this.name = name;
this.age = age;
this.gender = gender;
this.mobile = mobile;
}
public void show() {
System.out.println("姓名:"+name+",年龄:"+age+",性别:"+gender+",品牌:"+mobile.getBrand()+",型号"+mobile.getType()+",颜色:"+mobile.getColor()+",价格:"+mobile.getPrice());
}
}
class Mobile{
private String brand;
private String type;
private String color;
private double price;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Mobile() {
super();
}
public Mobile(String brand, String type, String color, double price) {
super();
this.brand = brand;
this.type = type;
this.color = color;
this.price = price;
}
}
接口
接口interface : 叫做扩展功能
定义格式:
interface 接口名{}
注意事项:
1. 接口中只能定义常量,默认public static final修饰
2. 接口中只能定义抽象方法(1.8之前) 默认是public abstract 修饰
3. 接口不能创建对象,使用子类向上转型
4. 接口的子类: 实现了接口的类 class 子类名 implements 接口1,接口2{}
5. 接口的子类要么实现接口中所有的抽象方法要么自己是一个抽象类
6. 一个类可以实现多个接口,并且可以在继承类的同时实现多个接口
7. 接口中没有构造方法
8. jdk8之后接口中可以定义已经实现的方法,但是必须使用static/default 修饰
9. 接口不能实现接口,只能继承接口,并且可以多继承
class 子类名 implements 接口1,接口2{}
练习1:
定义一个接口,定义两个抽象方法,写一个类实现该接口,并实现里面的方法,使用接口多态创建对象,并调用方法
/**
- . 定义一个接口InterA, 里面包含一个抽象方法,一个常量值a=100
- . 定义一个接口,InterB,继承接口InterA, 在写一个抽象方法
- . 定义个类Test,
- . 定义一个类Demo 继承Test 并 实现 InterB,实现里面所有的抽象方法
- . 在测试类中,创建InterB 类型的变量,调用里面的方法
*/
public class InterfaceTest {
public static void main(String[] args) {
InterB b = new Demo();// 接口的多态
b.test();
b.test2();
}
}
interface InterA{
void test();
int a = 100;
}
interface InterB extends InterA{
public void test2();
}
class Test{
}
class Demo extends Test implements InterB{
@Override
public void test() {
System.out.println("test");
}
@Override
public void test2() {
System.out.println("test2");
}
}
练习2:
编写一个抽象类Animal，抽象类中包括属性：name（String类型），抽象方法：speak()。
编写一个宠物接口pet，接口中包括方法：eat()。
再编写一个类cat，实现该接口和抽象类中的所有方法。
speat(): “miao, my name is xxx”
eat(): “I want to eat some fish”
在main中进行测试，输出：
给猫赋值一个名字,调用speak,eat 方法
public class InterfaceTest2 {
public static void main(String[] args) {
Pet p = new Cat();
p.eat();
//p.speak();//speak 并不存在与Pet接口中,所有他是子类中独有的方法,在多态的时候,调不了
Animal a = new Cat("小花");
a.speak();
//a.eat();//不能调子中独有的
}
}
//the type animal is already defined: 代表本包中已经有该名字的类: 换一个名: 建一个包
abstract class Animal{
String name;
abstract public void speak();
}
interface Pet{
void eat();
}
class Cat extends Animal implements Pet{
public Cat() {}
public Cat(String name) {
this.name = name;
}
@Override
public void eat() {
System.out.println("I want to eat some fish");
}
@Override
public void speak() {
System.out.println("miao, my name is "+name);
}
}
带包编译
使用notepad++ 编写一个带包的HelloWorld
package com.doit.test;
class HelloWorld{
public static void main(String[]args){
System.out.println("hello world");
}
}
使用命令行如何执行:
package com.doit.test;
手动式:
-
使用javac命令编译 javac 文件名.java javac HelloWorld.java
-
在类所在的文件夹下,按照包的格式把对应的文件夹创建出来,把.class文件拷贝到文件夹中
使用java 包名.类名 运行
自动式:
- javac(空格) -d (空格).(空格) 文件名.java
- java 包名.类名
导包: import 全类名;
顺序: package import class
权限修饰符
public: 修饰类, 修饰变量和方法 , 权限最大,可以在任意包内调用
protected: 修饰变量和方法 , 当前包内 随意访问 ,跨包只能在继承过父类的子类中使用
(default)/package: 修饰类,变量,方法 , 只能在当前包内访问
private: 修饰方法和变量 , 只能在本类中访问
protected: 修饰方法和变量
可以在不同包的子类中访问, 可以使用super关键字,创建子类的对象访问(创建父类的对象无法访问)
修饰外部类的修饰符:
public (default) final abstract
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
