?繼承的實現
1, 繼承的基本概念? : 擴展父類的功能
2,Java中使用extends關鍵字完成繼承? ? ? class 子類 extends 父類{}
代碼:
class Person{
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void tel() {
// System.out.println("姓名"+getName()+" 年齡"+getAge());
}
}
class Student extends Person{
private int score;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void want() {
System.out.println("成績"+getScore()+"姓名"+getName()+" 年齡"+getAge());
}
}
public class ExtendsDemo01 {
public static void main(String[] args) {
Student stu = new Student();
stu.setAge(13);
stu.setName("zhangsan");
stu.setScore(100);
stu.tel();
繼承的限制
1, 在Java中只允許單繼承, 但可以多層集成
2, 子類不能直接訪問父類的私有成員, ?需要寫setter和getter方法
子類對象的實例化
1, 在子類對象實例化之前,必須先調用父類中的構造方法, 之后調用子類構造方法
代碼:
class Father{
private int age;
public Father(){
System.out.println("父類的構造方法");
}
}
class Son extends Father{
public Son(){
System.out.println("子類的構造方法");
}
}
public class ExtendsDemo03 {
public static void main(String[] args) {
Son son = new Son();
} //控制臺打印結構: 先:父類的構造方法 再:子類的構造方法
}
Java方法重寫與super關鍵字
方法的重寫
1, 在繼承中, 也存在著重寫的概念, 其實就是子類定義了和父類同名的方法
2, 定義: ?方法名稱相同, 返回值類型相同, 參數也相同
3, 重寫限制: ?被子類重寫的方法不能擁有比父類方法更加嚴格的訪問權限
4, 訪問權限: private < default < public
super關鍵字
1, super關鍵字: 強行調用父類的方法的執行
2, super不一定在重寫中使用, 也可以表示那些方法時從父類中繼承而來的
代碼:
class A{
public void tell() {
System.out.println("我是父類的tell方法");
}
void say(){
System.out.println("我是父類的say方法");
}
}
class B extends A{
public void tell() {
super.tell();
System.out.println("我重寫了父類的tell方法");
}
void say(){
super.say();
System.out.println("我重寫了父類的say方法");
}
}
public class ExtendDemo04 {
public static void main(String[] args) {
// TODO Auto-generated method stub
B b = new B();
b.tell();
b.say();
}}
重寫與重載的區別:
final關鍵字
1, final關鍵字在java中被稱為完結器, 表示最終的意思
2, final能聲明類, 方法, 屬性: 1)使用final聲明的類不能被繼承 ?2)使用final聲明的方法不能被重寫 ?3)使用final聲明的變量變成常量, 常量是不可以被修改的, 用final修飾的變量名稱一般用大寫字母
抽象類
1, 抽象類概念: ?包含一個抽象方法的類就是抽象類
2, 抽象方法: 聲明而未被實現的方法, 抽象方法必須使用abstract關鍵字聲明
3, 抽象類被子類繼承, 子類(如果不是抽象類)必須重新抽象類中的所有抽象方法
4, 定義格式:
5, 抽象類不能直接實例化, 要通過其子類進行實例化
代碼:
abstract class ABs{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void tel();
}
class ABsDemo extends ABs{
@Override
public void tel() {
System.out.println("年齡為:"+getAge());
}
}
public class AbsDemo001 {
public static void main(String[] args) {
ABsDemo a = new ABsDemo();
a.setAge(20);
a.tel();
}}
接口:
1, 接口是Java中最重要的概念, 接口可以理解為一種特殊的類, 里面全部是由全局常量和公共的抽象方法所組成
2, 接口的格式:?
3, 接口的實現也必須通過子類, 使用關鍵字implements, 而且接口是可以多實現的
4, 一個子類可以同時繼承抽象和實現接口
5, 一個接口不能繼承一個抽象類,但是卻可以通過exends關鍵字同時繼承多個接口,實現接口的多繼承
代碼:
//接口類
interface inter1{
public static final int AGER = 100;
public abstract void tel();
}
interface inter2{
public abstract void say();
}
//抽象類
abstract class AbS{
public abstract void print();
}
//一個接口可以通過extends關鍵字同時繼承多個接口, 實現接口的多繼承
interface inter3 extends inter1, inter2{
}
// 一個子類可以同時繼承抽象和實現接口
class A extends ABs implements inter1, inter2{
@Override
public void tel() {
System.out.println(AGER);
}
@Override
public void say() {
}
public void print() {
}
}
public class InterDemo01 {
public static void main(String[] args) {
A a = new A();
a.tel();
a.say();
a.print();
}
}
方法的定義
1, 方法就是一段可重復調用的代碼段
2, 定義格式: ? 訪問修飾符 ?返回值類型 ?方法名() { 方法主體 }
方法重載: ?方法名稱相同, 但是參數的類型和個數不同, 通過傳遞參數的個數和類型不同來完成不同的功能
代碼:
public static void tell(int i, int j) {
System.out.println(i+j);
}
public static void tell(int i, int j, int n) {
System.out.println(i+j+n);
}
public static void main(String[] args) {
tell(10, 20);
tell(10, 20, 3);
}
類的定義, 聲明及使用
1, class 類名稱{ 屬性 ? 方法}
2, 聲明一個類需要通過一個關鍵字class
類與對象的關系:
1, 類是對某一類事物的描述,是抽象的,概念上的意義, 對象是實際存在的該類事物的每一個個體, 也被稱為實例
內存劃分
面向對象編程思想
面向過程: 不去想做什么樣子的盒子, 隨機取工具制作
面向對象: 先想好做一個什么樣的盒子, 再去找對應的工具去做
面向對象三大基本特征: 封裝性: 對外包不可見 ? 繼承: 擴展類的功能 ? 多態性: 方法的重載,對象的多態性
方法的遞歸調用
1, 遞歸調用是一種特殊的調用形式, 就是方法自己調用自己
代碼:
public static void main(String[] args) {
// TODO Auto-generated method stub
add(100);
}
//? 1+...+100的和
public static int? add(int num) {
if (num == 1) {//程序出口
return 1;
} else {
return num+add(num-1);
}}
Java關系運算
1, Java還有提供了對兩個量之間的關系進行比較的運算, 成為關系運算
2, 關系運算的結果是true或false
案例: 鍵盤輸入分數, 顯示該分數是否及格:
代碼:?
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("輸入分數:");
int score = scanner.nextInt();
boolean isPass = score >= 60;
if (isPass) {
System.out.println(score + "及格" + isPass);
} else {
System.out.println(score + "不及格" + isPass);
}}
引用傳遞
代碼:
class Ref1{
int temp = 10;
}
public class RefDemo01 {
public static void main(String[] args) {
Ref1 r1 = new Ref1();
r1.temp = 20;
System.out.println(r1.temp);//20
tell(r1);
System.out.println(r1.temp);//30
}
public static void tell(Ref1 r2) {
r2.temp = 30;
}}
this關鍵字
1, 表示類中的屬性和調用方法
2,調用本類中的構造方法
3, 表示當前對象
代碼:
class Teacher{
private String name;
private int age;
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;
}
//this.age 表示類中的屬性和方法
public Teacher(String name, int age){
this();//調用本類中的構造方法, 必須放在第一行
this.age = age;
this.name = name;
}
public Teacher() {
System.out.println("無慘構造方法");
}
public void tel() {
System.out.println("姓名:"+this.getName() + "\n年齡"+ this.getAge());
}
}
public class ThisDemo01 {
public static void main(String[] args) {
Teacher t = new Teacher("zhang", 13);
t.tel();}}
代碼: 表示當前對象
class Peopue{
public void tell() {
System.out.println(this);//com.jikexueyuan.thisdemo.Peopue@677327b6
}
}
public class ThisDemo02 {
public static void main(String[] args) {
Peopue p = new Peopue();
System.out.println(p);
p.tell();//com.jikexueyuan.thisdemo.Peopue@677327b6
}
}
