Java面向對象理解_代碼塊_繼承_多態_抽象_接口
面線對象：java
/*
成員變量和局部變量的區別?
A:在類中的位置不一樣
成員變量：在類中方法外
局部變量：在方法定義中或者方法聲明上
B:在內存中的位置不一樣
成員變量：在堆內存
局部變量：在棧內存
C:生命週期不一樣
成員變量：隨着對象的建立而存在，隨着對象的消失而消失
局部變量：隨着方法的調用而存在，隨着方法的調用完畢而消失
D:初始化值不一樣
成員變量：有默認初始化值
局部變量：沒有默認初始化值，必須定義，賦值，而後才能使用。
注意事項：
局部變量名稱能夠和成員變量名稱同樣，在方法中使用的時候，採用的是就近原則。
*/
class Varialbe {
//成員變量
//int num = 10;
int num; //0
public void show() {
//int num2 = 20; //局部變量
//可能還沒有初始化變量num2
//int num2; //沒有默認值
int num2 = 20;
System.out.println(num2);
//int num = 100;
System.out.println(num);
}
}
class VariableDemo {
public static void main(String[] args) {
Varialbe v = new Varialbe();
System.out.println(v.num); //訪問成員變量
v.show();
}
}
===================================================================
/*
形式參數的問題：
基本類型：形式參數的改變不影響實際參數
引用類型：形式參數的改變直接影響實際參數
*/
//形式參數是基本類型
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
//形式參數是引用類型
class Student {
public void show() {
System.out.println("我愛學習");
}
}
class StudentDemo {
//若是你看到了一個方法的形式參數是一個類類型(引用類型)，這裏其實須要的是該類的對象。
public void method(Student s) { //調用的時候，把main方法中的s的地址傳遞到了這裏 Student s = new Student();
s.show();
}
}
class ArgsTest {
public static void main(String[] args) {
//形式參數是基本類型的調用
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
System.out.println("--------------");
//形式參數是引用類型的調用
//需求：我要調用StudentDemo類中的method()方法
StudentDemo sd = new StudentDemo();
//建立學生對象
Student s = new Student();
sd.method(s); //把s的地址給到了這裏
}
}
==================================================
/*
匿名對象：就是沒有名字的對象。
匿名對象的應用場景：
A:調用方法，僅僅只調用一次的時候。
注意：調用屢次的時候，不適合。
那麼，這種匿名調用有什麼好處嗎?
有，匿名對象調用完畢就是垃圾。能夠被垃圾回收器回收。
B:匿名對象能夠做爲實際參數傳遞
*/
class Student {
public void show() {
System.out.println("我愛學習");
}
}
class StudentDemo {
public void method(Student s) {
s.show();
}
}
class NoNameDemo {
public static void main(String[] args) {
//帶名字的調用
Student s = new Student();
s.show();
s.show();
System.out.println("--------------");
//匿名對象
//new Student();
//匿名對象調用方法
new Student().show();
new Student().show(); //這裏實際上是從新建立了一個新的對象
System.out.println("--------------");
//匿名對象做爲實際參數傳遞
StudentDemo sd = new StudentDemo();
//Student ss = new Student();
//sd.method(ss); //這裏的s是一個實際參數
//匿名對象
sd.method(new Student());
//在來一個
new StudentDemo().method(new Student());
}
}
====================================================================/*
private:
是一個權限修飾符
能夠修飾成員變量和成員方法
被其修飾的成員只能在本類中被訪問
*/
class Demo {
//int num = 10;
//用private修飾
private int num = 10;
public void show() {
System.out.println(num);
}
private void method() {
System.out.println("method");
}
public void function() {
method();
}
}
class PrivateDemo {
public static void main(String[] args) {
Demo d = new Demo();
//不能方法私有的成員變量
//System.out.println(d.num);
d.show();
//不能訪問私有的成員方法
//d.method();
d.function();
}
}
============================================================
/*
定義一個學生類：
成員變量：name，age
成員方法：show()方法
咱們在使用這個案例的過程當中，發現了一個問題：
經過對象去給成員變量賦值，能夠賦值一些非法的數據。
這是不合理的。
應該是這個樣子的：在賦值以前，先對數據進行判斷。
判斷到底在哪裏作比較合適呢?
StudentDemo類是一個測試類，測試類通常只建立對象，調用方法。
因此，這個判斷應該定義在Student類中。
而咱們在成員變量的位置可不能夠進行數據判斷呢?
是不能夠的，由於作數據校驗，必需要依靠一些邏輯語句。
邏輯語句是應該定義在方法中的，因此，咱們最終決定在Student類中提供一個方法
來對數據進行校驗。
按照咱們前面的分析，咱們給出了一個方法進行校驗。
可是呢，它恰恰不調用方法來賦值，仍是直接賦值了，
這樣咱們的方法就沒有起到做用。
我就應該要求你必須使用個人方法，而不能直接調用成員變量賦值。
怎麼去強制要求不能直接使用成員變量呢?
針對這種狀況，Java就提供了一個關鍵字 private
private:私有的。能夠修飾成員變量和成員方法。
注意：被private修飾的成員只能在本類中訪問。
其實我講到如今講解的是一個封裝的思想。
封裝：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。
*/
class Student {
//姓名
String name;
//年齡
private int age;
//寫一個方法對數據進行校驗
/*
返回值類型：void
參數列表：int a
*/
public void setAge(int a) {
if(a < 0 || age > 120) {
System.out.println("你給的年齡有問題");
}else {
age = a;
}
}
//show()方法,顯示全部成員變量值
public void show() {
System.out.println("姓名："+name);
System.out.println("年齡："+age);
}
}
class StudentDemo {
public static void main(String[] args) {
//建立學生對象
Student s = new Student();
s.show();
System.out.println("--------------");
//給成員變量賦值
s.name = "林青霞";
//s.age = 27;
s.setAge(27);
s.show();
System.out.println("--------------");
//給age賦值
//s.age = -27; //這個數據是不合理的
//經過方法給值
s.setAge(-27);
s.show();
System.out.println("--------------");
}
}
====================================================================/*
封裝和private的應用：
A:把成員變量用private修飾
B:提升對應的getXxx()和setXxx()方法
*/
//定義學生類
class Student {
//姓名
private String name;
//年齡
private int age;
//姓名獲取值
public String getName() {
return name;
}
//姓名設置值
public void setName(String n) {
name = n;
}
//年齡獲取值
public int getAge() {
return age;
}
//年齡賦值
public void setAge(int a) {
age = a;
}
}
//測試類
class StudentTest {
public static void main(String[] args) {
//建立學生對象
Student s = new Student();
//使用成員變量
//錯誤：被私有修飾了，外界不能直接訪問了
//System.out.println(s.name+"---"+s.age);
System.out.println(s.getName()+"---"+s.getAge());
//給成員變量賦值
//s.name = "林青霞";
//s.age = 27;
//經過方法給賦值
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName()+"---"+s.getAge());
}
}
======================================================
/*
做業：請把手機類寫成一個標準類，而後建立對象測試功能。
手機類：
成員變量：
品牌：String brand;
價格：int price;
顏色：String color;
成員方法：
針對每個成員變量給出對應的getXxx()/setXxx()方法。
最後定義測試：
建立一個對象，先經過getXxx()方法輸出成員變量的值。這一次的結果是：null---0---null
而後經過setXxx()方法給成員變量賦值。再次輸出結果。這一次的結果是：三星---2999---土豪金
*/
class Phone {
//品牌
private String brand;
//價格
private int price;
//顏色
private String color;
//getXxx()和setXxx()方法
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
class PhoneTest {
public static void main(String[] args) {
//建立手機對象
Phone p = new Phone();
//直接輸出默認值
System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
//給成員變量賦值
p.setBrand("三星");
p.setPrice(2999);
p.setColor("土豪金");
//再次輸出
System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
}
}
===========================================================
/*
咱們曾經曰：起名字要作到見名知意。
this:是當前類的對象引用。簡單的記，它就表明當前類的一個對象。
注意：誰調用這個方法，在該方法內部的this就表明誰。
this的場景：
解決局部變量隱藏成員變量
*/
//定義學生類
class Student {
//姓名
private String name;
//年齡
private int age;
//姓名獲取值
public String getName() {
return name;
}
//姓名設置值
public void setName(String name) { //name = "林青霞";
//name = name; //變量的使用規則：就近原則
//這裏是類名，目前尚未說過相似的用法，因此這個是有問題的
//這裏的調用只能經過對象名
//這個對象若是存在，它應該表明的是Student的一個對象。
//那麼，誰可以表明當前類的對象呢? java就提供了一個關鍵字 this
//Student.name = name;
this.name = name;
}
//年齡獲取值
public int getAge() {
return age;
}
//年齡賦值
public void setAge(int age) {
this.age = age;
}
}
//測試類
class StudentTest {
public static void main(String[] args) {
//建立學生對象
Student s = new Student();
//給成員變量賦值
s.setName("林青霞");
s.setAge(27);
//獲取數據
System.out.println(s.getName()+"---"+s.getAge());
}
}
============================
/*
標準的代碼改進版
this:哪一個對象調用那個方法，this就表明那個對象
*/
class Student {
private String name;
private int age;
public String getName() {
return name; //這裏實際上是隱含了this
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class StudentTest2 {
public static void main(String[] args) {
//建立一個對象
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//建立第二個對象
Student s2 = new Student();
s2.setName("劉意");
s2.setAge(30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}
=============================================================
/*
構造方法：
給對象的數據進行初始化
格式：
A:方法名與類名相同
B:沒有返回值類型，連void都沒有
C:沒有具體的返回值
*/
class Student {
private String name; //null
private int age; //0
public Student() {
System.out.println("這是構造方法");
}
}
class ConstructDemo {
public static void main(String[] args) {
//建立對象
Student s = new Student();
System.out.println(s); //Student@e5bbd6
}
}
=========================================================
/*
咱們一直在使用構造方法，可是，咱們確沒有定義構造方法，用的是哪裏來的呢?
構造方法的注意事項:
A:若是咱們沒有給出構造方法，系統將自動提供一個無參構造方法。
B:若是咱們給出了構造方法，系統將再也不提供默認的無參構造方法。
注意：這個時候，若是咱們還想使用無參構造方法，就必須本身給出。建議永遠本身給出無參構造方法
給成員變量賦值有兩種方式：
A:setXxx()
B:構造方法
*/
class Student {
private String name;
private int age;
public Student() {
//System.out.println("我給了，你還給不");
System.out.println("這是無參構造方法");
}
//構造方法的重載格式
public Student(String name) {
System.out.println("這是帶一個String類型的構造方法");
this.name = name;
}
public Student(int age) {
System.out.println("這是帶一個int類型的構造方法");
this.age = age;
}
public Student(String name,int age) {
System.out.println("這是一個帶多個參數的構造方法");
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name+"---"+age);
}
}
class ConstructDemo2 {
public static void main(String[] args) {
//建立對象
Student s = new Student();
s.show();
System.out.println("-------------");
//建立對象2
Student s2 = new Student("林青霞");
s2.show();
System.out.println("-------------");
//建立對象3
Student s3 = new Student(27);
s3.show();
System.out.println("-------------");
//建立對象4
Student s4 = new Student("林青霞",27);
s4.show();
}
}
==================================================================
/*
類的組成：成員變量，成員方法
今天咱們又加入了一個新的成員：構造方法。
之後再提類的組成：
成員變量
構造方法
成員方法
根據返回值：
void類型
非void類型
形式參數：
空參方法
非空參方法
*/
class Student {
public String getString() {
return "helloworld";
}
public void show() {
System.out.println("show");
}
public void method(String name) {
System.out.println(name);
}
public String function(String s1,String s2) {
return s1+s2;
}
}
class StudentDemo {
public static void main(String[] args) {
//建立對象
Student s = new Student();
//調用無參無返回值方法
s.show();
//調用無參有返回值方法
String result = s.getString();
System.out.println(result);
//調用帶參無返回值的方法
s.method("林青霞");
//調用帶參帶返回值的方法
String result2 = s.function("hello","world");
System.out.println(result2);
}
}
=============================================================
/*
一個標準代碼的最終版。
學生類：
成員變量：
name，age
構造方法：
無參，帶兩個參
成員方法：
getXxx()/setXxx()
show()：輸出該類的全部成員變量值
給成員變量賦值：
A:setXxx()方法
B:構造方法
輸出成員變量值的方式：
A:經過getXxx()分別獲取而後拼接
B:經過調用show()方法搞定
*/
class Student {
//姓名
private String name;
//年齡
private int age;
//構造方法
public Student() {
}
public Student(String name,int age) {
this.name = name;
this.age = 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;
}
//輸出全部的成員變量值
public void show() {
System.out.println(name+"---"+age);
}
}
//測試類
class StudentTest {
public static void main(String[] args) {
//方式1給成員變量賦值
//無參構造+setXxx()
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
//輸出值
System.out.println(s1.getName()+"---"+s1.getAge());
s1.show();
System.out.println("----------------------------");
//方式2給成員變量賦值
Student s2 = new Student("劉意",30);
System.out.println(s2.getName()+"---"+s2.getAge());
s2.show();
}
}
====================================================================/*
需求：
定義一個員工類,本身分析出幾個成員，
而後給出成員變量，構造方法，getXxx()/setXxx()方法，
以及一個顯示全部成員信息的方法。並測試。
分析：
員工
成員變量：
員工編號，姓名，年齡
構造方法：
無參構造方法
成員方法：
getXxx()/setXxx()
show();
*/
class Employee {
//員工編號
private String employeeId;
//姓名
private String name;
//年齡
private int age;
//構造方法
public Employee() {}
//getXxx()/setXxx()
public String getEmployeeId() {
return employeeId;
}
public void setEmployeeId(String employeeId) {
this.employeeId = employeeId;
}
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 void show() {
System.out.println("員工編號是："+employeeId+"的這我的是："+name+"的年齡是："+age);
}
}
class EmployeeTest {
public static void main(String[] args) {
//建立對象
Employee e = new Employee();
//給成員變量賦值
e.setEmployeeId("czbk9527");
e.setName("唐伯虎");
e.setAge(18);
//獲取數據
//System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());
//咱們在Employee類中定義了一個show方法。因此，咱們改進一下，使用show方法
e.show();
}
}
===================================================================
/*
定義一個類MyMath,提供基本的加減乘除功能，而後進行測試。
*/
import java.util.Scanner;
class MyMath {
//加法功能
public int add(int a,int b) {
return a + b;
}
//減法功能
public int sub(int a,int b) {
return a - b;
}
//乘法功能
public int mul(int a,int b){
return a * b;
}
//除法功能
public int div(int a,int b) {
return a / b;
}
}
//測試類
class MyMathTest {
public static void main(String[] args) {
//建立鍵盤錄入對象
Scanner sc = new Scanner(System.in);
System.out.println("請輸入第一個操做數：");
int firstNumber = sc.nextInt();
System.out.println("請輸入第二個操做數：");
int secondNumber = sc.nextInt();
//建立MyMath對象，並使用
MyMath mm = new MyMath();
System.out.println("加法結果："+mm.add(firstNumber,secondNumber));
System.out.println("減法結果："+mm.sub(firstNumber,secondNumber));
System.out.println("乘法結果："+mm.mul(firstNumber,secondNumber));
System.out.println("除法結果："+mm.div(firstNumber,secondNumber));
}
}
==================================================================
/*
定義一個類Demo,其中定義一個求兩個數據和的方法，
定義一個測試了Test，進行測試。
變量何時定義爲成員變量：
若是這個變量是用來描述這個類的信息的，那麼，該變量就應該定義爲成員變量。
變量到底定義在哪裏好呢?
變量的範圍是越小越好。由於能及時的被回收。
*/
//方式1
/*
class Demo {
public int sum() {
int a = 10;
int b = 20;
int c = a + b;
return c;
}
}
*/
//方式1知足了咱們的要求，可是很差。
//由於參與操做的數據如今是固定的。
//方式2
/*
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
*/
//方式2能夠知足咱們的要求，可是呢咱們學習過來面向對象的思想。
//我就再想，a，b可不能夠定義爲成員變量呢?
//若是能夠，咱們再改進一版
class Demo {
int a;
int b;
public int sum() {
return a + b;
}
}
//雖然這種方式能夠，而且好像是符合了面向對象的思想。
//可是很差。
//由於咱們曾經說過：類是一組相關的屬性和行爲的集合。
//而且類是經過事物轉換過來的
//而類中的成員變量就是事物的屬性
//屬性是用來描述事物的
//同理：成員變量實際上是用來描述類的。
//測試類
class Test {
public static void main(String[] args) {
//建立對象
//方式1測試
/*
Demo d = new Demo();
System.out.println(d.sum());
*/
//方式2測試
/*
Demo d = new Demo();
int a = 10;
int b = 20;
System.out.println(d.sum(a,b));
*/
//方式3測試
Demo d = new Demo();
d.a = 10;
d.b = 20;
System.out.println(d.sum());
}
}
=============================================
/*
定義一個長方形類,定義 求周長和麪積的方法，
而後定義一個測試了Test2，進行測試。
長方形的類：
成員變量：
長，寬
成員方法：
求周長：(長+寬)*2;
求面積：長*寬
注意：
import必須出如今全部的class前面。
*/
import java.util.Scanner;
class ChangFangXing {
//長方形的長
private int length;
//長方形的寬
private int width;
public ChangFangXing(){}
//僅僅提供setXxx()便可
public void setLength(int length) {
this.length = length;
}
public void setWidth(int width) {
this.width = width;
}
//求周長
public int getZhouChang() {
return (length + width) * 2;
}
//求面積
public int getArea() {
return length * width;
}
}
class Test2 {
public static void main(String[] args) {
//建立鍵盤錄入對象
Scanner sc = new Scanner(System.in);
System.out.println("請輸入長方形的長：");
int length = sc.nextInt();
System.out.println("請輸入長方形的寬：");
int width = sc.nextInt();
//建立對象
ChangFangXing cfx = new ChangFangXing();
//先給成員變量賦值
cfx.setLength(length);
cfx.setWidth(width);
System.out.println("周長是："+cfx.getZhouChang());
System.out.println("面積是："+cfx.getArea());
}
}
==============================================================================
/*
main方法的格式講解：
public static void main(String[] args) {...}
public:公共的，訪問權限是最大的。因爲main方法是被jvm調用，因此權限要夠大。
static:靜態的，不須要建立對象，經過類名就能夠。方便jvm的調用。
void:由於咱們曾經說過，方法的返回值是返回給調用者，而main方法是被jvm調用。你返回內容給jvm沒有意義。
main:是一個常見的方法入口。我見過的語言都是以main做爲入口。
String[] args:這是一個字符串數組。值去哪裏了?
這個東西到底有什麼用啊?怎麼給值啊?
這個東西早期是爲了接收鍵盤錄入的數據的。
格式是：
java MainDemo hello world java
*/
class MainDemo {
public static void main(String[] args) {
//System.out.println(args); //[Ljava.lang.String;@175078b
//System.out.println(args.length); //0
//System.out.println(args[0]); //ArrayIndexOutOfBoundsException
//接收數據後
System.out.println(args);
System.out.println(args.length);
//System.out.println(args[0]);
for(int x=0; x<args.length; x++) {
System.out.println(args[x]);
}
}
}
===================================
/*
定義一我的類
姓名和年齡都是變化的，這個我能接收，由於每一個人的姓名和年齡是不一樣的。
可是，咱們如今選取的幾我的都是中國人，他們的國籍是同樣的。
同樣的國籍，我每次建立對象，在堆內存都要開闢這樣的空間，
我就以爲有點浪費了。怎麼辦呢?
針對多個對象有共同的這樣的成員變量值的時候，
Java就提升了一個關鍵字來修飾：static。
*/
class Person {
//姓名
String name;
//年齡
int age;
//國籍
//String country;
static String country;
public Person(){}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public Person(String name,int age,String country) {
this.name = name;
this.age = age;
this.country = country;
}
public void show() {
System.out.println("姓名："+name+",年齡："+age+",國籍："+country);
}
}
class PersonDemo {
public static void main(String[] args) {
//建立對象1
Person p1 = new Person("鄧麗君",16,"中國");
p1.show();
//建立對象2
//Person p2 = new Person("楊冪",22,"中國");
//p2.show();
Person p2 = new Person("楊冪",22);
p2.show();
//建立對象3
//Person p3 = new Person("鳳姐",20,"中國");
//p3.show();
Person p3 = new Person("鳳姐",20);
p3.show();
p3.country = "美國";
p3.show();
p1.show();
p2.show();
/*
姓名：鄧麗君,年齡：16,國籍：中國
姓名：楊冪,年齡：22,國籍：中國
姓名：鳳姐,年齡：20,國籍：中國
姓名：鳳姐,年齡：20,國籍：美國
姓名：鄧麗君,年齡：16,國籍：美國
姓名：楊冪,年齡：22,國籍：美國
/*
}
}
====================================================================/*
static的特色：(它能夠修飾成員變量，還能夠修飾成員方法)
A:隨着類的加載而加載
回想main方法。
B:優先於對象存在
C:被類的全部對象共享
舉例：我們班級的學生應該共用同一個班級編號。
其實這個特色也是在告訴咱們何時使用靜態?
若是某個成員變量是被全部對象共享的，那麼它就應該定義爲靜態的。
舉例：
飲水機(用靜態修飾)
水杯(不能用靜態修飾)
D:能夠經過類名調用
其實它自己也能夠經過對象名調用。
推薦使用類名調用。
靜態修飾的內容通常咱們稱其爲：與類相關的，類成員
*/
class Student {
//非靜態變量
int num = 10;
//靜態變量
static int num2 = 20;
}
class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.num);
System.out.println(Student.num2);
System.out.println(s.num2);
}
}
===========================================================
/*
static關鍵字注意事項
A:在靜態方法中是沒有this關鍵字的
如何理解呢?
靜態是隨着類的加載而加載，this是隨着對象的建立而存在。
靜態比對象先存在。
B:靜態方法只能訪問靜態的成員變量和靜態的成員方法
靜態方法：
成員變量：只能訪問靜態變量
成員方法：只能訪問靜態成員方法
非靜態方法：
成員變量：能夠是靜態的，也能夠是非靜態的
成員方法：但是是靜態的成員方法，也能夠是非靜態的成員方法。
簡單記：
靜態只能訪問靜態。
*/
class Teacher {
public int num = 10;
public static int num2 = 20;
public void show() {
System.out.println(num); //隱含的告訴你訪問的是成員變量
System.out.println(this.num); //明確的告訴你訪問的是成員變量
System.out.println(num2);
//function();
//function2();
}
public static void method() {
//沒法從靜態上下文中引用非靜態 變量 num
//System.out.println(num);
System.out.println(num2);
//沒法從靜態上下文中引用非靜態 方法 function()
//function();
function2();
}
public void function() {
}
public static void function2() {
}
}
class TeacherDemo {
public static void main(String[] args) {
//建立對象
Teacher t = new Teacher();
t.show();
System.out.println("------------");
t.method();
}
}
二.代碼塊和繼承
/*
我想要對數組進行操做
在同一個文件夾下，類定義在兩個文件中和定義在一個文件中其實同樣的。
*/
class ArrayDemo {
public static void main(String[] args) {
//定義數組
int[] arr = {28,55,37,46,19};
//需求：遍歷數組
/*
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
*/
//若是我有多個數組都要進行遍歷，那麼，代碼的重複度就很高
//如何改進呢?用方法改進
//調用
//靜態方法
//printArray(arr);
//非靜態方法
//ArrayDemo ad = new ArrayDemo();
//ad.printArray(arr);
//測試類的做用：建立其餘類的對象，調用其餘類的功能。
//而咱們如今的操做是跟數組相關的，因此，你應該把這些操做定義到數組操做類中
//定義一個數組的操做類
//有了數組操做類以後的調用
//ArrayTool at = new ArrayTool();
//at.printArray(arr);
//方法改進爲靜態後，就能夠直接經過類名調用
ArrayTool.printArray(arr);
}
/*
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
*/
//假設該方法不是靜態的
/*
public void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
*/
}
======================================
class ArrayTool {
//把構造方法私有，外界就不能在建立對象了
private ArrayTool(){}
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
}
==============================
/*
我想要對數組進行操做
如何製做一個說明書呢?
A:寫一個工具類
B:對這個類加入文檔註釋
怎麼加呢?
加些什麼東西呢?
C:用工具解析文檔註釋
javadoc工具
D:格式
javadoc -d 目錄 -author -version ArrayTool.java
目錄：就能夠寫一個文件夾的路徑
製做幫助文檔出錯：
找不到能夠文檔化的公共或受保護的類：告訴咱們類的權限不夠
*/
class ArrayDemo {
public static void main(String[] args) {
//定義數組
int[] arr = {28,55,37,46,19};
//遍歷
ArrayTool.printArray(arr);
//獲取最值
int max = ArrayTool.getMax(arr);
System.out.println("max:"+max);
//獲取55的索引值
int index = ArrayTool.getIndex(arr,55);
System.out.println("index:"+index);
}
}
=============================================
/**
* 這是針對數組進行操做的工具類
* @author 劉意
* @version V.10
*/
public class ArrayTool {
//把構造方法私有，外界就不能在建立對象了
/**
* 這是私有構造
*/
private ArrayTool(){}
/**
* 這是遍歷數組的方法，遍歷後的格式是：[元素1, 元素2, 元素3, ...]
* @param arr 這是要被遍歷的數組
*/
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
/**
* 這是獲取數組中最大值的方法
* @param arr 這是要獲取最大值的數組
* @return 返回數組中的最大值
*/
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}
/**
* 獲取指定元素在數組中第一次出現的索引，若是元素不存在，就返回-1
* @param arr 被查找的數組
* @param value 要查找的元素
* @return 返回元素在數組中的索引，若是不存在，返回-1
*/
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
====================================
/*
猜數字小遊戲(數據在1-100之間)
分析：
A:程序產生一個隨機數。(被猜的)
B:鍵盤錄入數據。(你猜的)
C:把你猜的和被猜的進行比較
a:大了
b:小了
c:猜中了
D:給出屢次猜的機會，猜中就結束。
while()循環，猜中就break
*/
import java.util.Scanner;
class GuessNumber {
public static void main(String[] args) {
//程序產生一個隨機數。(被猜的)
int number = (int)(Math.random()*100)+1;
//System.out.println(number);
//給出屢次猜的機會，猜中就結束。
while(true) {
//鍵盤錄入數據。(你猜的)
Scanner sc = new Scanner(System.in);
System.out.println("請輸入你要猜的數據(1-100):");
int guessNumber = sc.nextInt();
//把你猜的和被猜的進行比較
if(guessNumber > number) {
System.out.println("你猜的數據"+guessNumber+"大了");
}else if(guessNumber < number) {
System.out.println("你猜的數據"+guessNumber+"小了");
}else {
System.out.println("恭喜你，猜中了");
break;
}
}
}
}
=================================================
/*
Math:類包含用於執行基本數學運算的方法
因爲Math類在java.lang包下，因此不須要導包。
特色：
沒有構造方法，由於它的成員所有是靜態的。
掌握一個方法：
獲取隨機數
public static double random():返回帶正號的 double 值，該值大於等於 0.0 且小於 1.0。
*/
class MathDemo {
public static void main(String[] args) {
//獲取一個隨機數
//double d = Math.random();
//System.out.println(d);
//需求：我要獲取一個1-100之間的隨機數，腫麼辦?
for(int x=0; x<100; x++) {
int number = (int)(Math.random()*100)+1;
System.out.println(number);
}
}
}
==================================================================
1:打開幫助文檔
2:點擊顯示，找到索引，看到輸入框
3:知道你要找誰?以Scanner舉例
4:在輸入框裏面輸入Scanner，而後回車
5:看包
java.lang包下的類不須要導入，其餘的所有須要導入。
要導入：
java.util.Scanner
6:再簡單的看看類的解釋和說明，別忘了看看該類的版本
7:看類的結構
成員變量 字段摘要
構造方法 構造方法摘要
成員方法 方法摘要
8:學習構造方法
A:有構造方法 就建立對象
B:沒有構造方法 成員可能都是靜態的
9:當作員方法
A:左邊
是否靜態：若是靜態，能夠經過類名調用
返回值類型：人家返回什麼，你就用什麼接收。
B:右邊
看方法名：方法名稱不要寫錯
參數列表：人家要什麼，你就給什麼；人家要幾個，你就給幾個
=========================
/*
代碼塊：在Java中，使用{}括起來的代碼被稱爲代碼塊。
根據其位置和聲明的不一樣，能夠分爲
局部代碼塊:局部位置,用於限定變量的生命週期。
構造代碼塊:在類中的成員位置,用{}括起來的代碼。每次調用構造方法執行前，都會先執行構造代碼塊。
做用：能夠把多個構造方法中的共同代碼放到一塊兒，對對象進行初始化。
靜態代碼塊:在類中的成員位置,用{}括起來的代碼,只不過它用static修飾了。
做用：通常是對類進行初始化。
面試題?
靜態代碼塊,構造代碼塊,構造方法的執行順序?
靜態代碼塊 -- 構造代碼塊 -- 構造方法
靜態代碼塊：只執行一次
構造代碼塊：每次調用構造方法都執行
*/
class Code {
static {
int a = 1000;
System.out.println(a);
}
//構造代碼塊
{
int x = 100;
System.out.println(x);
}
//構造方法
public Code(){
System.out.println("code");
}
//構造方法
public Code(int a){
System.out.println("code");
}
//構造代碼塊
{
int y = 200;
System.out.println(y);
}
//靜態代碼塊
static {
int b = 2000;
System.out.println(b);
}
}
class CodeDemo {
public static void main(String[] args) {
//局部代碼塊
{
int x = 10;
System.out.println(x);
}
//找不到符號
//System.out.println(x);
{
int y = 20;
System.out.println(y);
}
System.out.println("---------------");
Code c = new Code();
System.out.println("---------------");
Code c2 = new Code();
System.out.println("---------------");
Code c3 = new Code(1);
}
}
=================================
/*
寫程序的執行結果。
林青霞都60了，我很傷心
我是main方法
Student 靜態代碼塊
Student 構造代碼塊
Student 構造方法
Student 構造代碼塊
Student 構造方法
*/
class Student {
static {
System.out.println("Student 靜態代碼塊");
}
{
System.out.println("Student 構造代碼塊");
}
public Student() {
System.out.println("Student 構造方法");
}
}
class StudentDemo {
static {
System.out.println("林青霞都60了，我很傷心");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
====================================================================/*
繼承概述：
把多個類中相同的內容給提取出來定義到一個類中。
如何實現繼承呢?
Java提供了關鍵字：extends
格式：
class 子類名 extends 父類名 {}
好處：
A:提升了代碼的複用性
B:提升了代碼的維護性
C:讓類與類之間產生了關係，是多態的前提
類與類產生了關係，其實也是繼承的一個弊端：
類的耦合性加強了。
開發的原則：低耦合，高內聚。
耦合：類與類的關係
內聚：就是本身完成某件事情的能力
*/
//使用繼承前
/*
class Student {
public void eat() {
System.out.println("吃飯");
}
public void sleep() {
System.out.println("睡覺");
}
}
class Teacher {
public void eat() {
System.out.println("吃飯");
}
public void sleep() {
System.out.println("睡覺");
}
}
*/
//使用繼承後
class Person {
public void eat() {
System.out.println("吃飯");
}
public void sleep() {
System.out.println("睡覺");
}
}
class Student extends Person {}
class Teacher extends Person {}
class ExtendsDemo {
public static void main(String[] args) {
Student s = new Student();
s.eat();
s.sleep();
System.out.println("-------------");
Teacher t = new Teacher();
t.eat();
t.sleep();
}
}
====================================================
/*
Java中繼承的特色：
A:Java只支持單繼承，不支持多繼承。
有些語言是支持多繼承，格式：extends 類1,類2,...
B:Java支持多層繼承(繼承體系)
*/
/*
class Father {}
class Mother {}
class Son exnteds Father {} //正確的
class Son extends Father,Mother {} // 錯誤的
*/
class GrandFather {
public void show() {
System.out.println("我是爺爺");
}
}
class Father extends GrandFather {
public void method(){
System.out.println("我是老子");
}
}
class Son extends Father {}
class ExtendsDemo2 {
public static void main(String[] args) {
Son s = new Son();
s.method(); //使用父親的
s.show(); //使用爺爺的
}
}
====================================================================/*
繼承的注意事項：
A:子類只能繼承父類全部非私有的成員(成員方法和成員變量)
B:子類不能繼承父類的構造方法，可是能夠經過super(立刻講)關鍵字去訪問父類構造方法。
C:不要爲了部分功能而去繼承
class A {
public void show1(){}
public void show2(){}
}
class B {
public void show2(){}
public void show3(){}
}
//咱們發現B類中出現了和A類同樣的show2()方法，因此，咱們就用繼承來體現
class B extends A {
public void show3(){}
}
這樣其實很差，由於這樣你不但有了show2(),還多了show1()。
有可能show1()不是你想要的。
那麼，咱們何時考慮使用繼承呢?
繼承其實體現的是一種關係："is a"。
Person
Student
Teacher
水果
蘋果
香蕉
橘子
採用假設法。
若是有兩個類A,B。只有他們符合A是B的一種，或者B是A的一種，就能夠考慮使用繼承。
*/
class Father {
private int num = 10;
public int num2 = 20;
//私有方法，子類不能繼承
private void method() {
System.out.println(num);
System.out.println(num2);
}
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
class Son extends Father {
public void function() {
//num能夠在Father中訪問private
//System.out.println(num); //子類不能繼承父類的私有成員變量
System.out.println(num2);
}
}
class ExtendsDemo3 {
public static void main(String[] args) {
// 建立對象
Son s = new Son();
//s.method(); //子類不能繼承父類的私有成員方法
s.show();
s.function();
}
}
====================================================================/*
類的組成：
成員變量：
構造方法：
成員方法：
而如今咱們又講解了繼承，因此，咱們就應該來考慮一下，類的組成部分的各自關係。
繼承中成員變量的關係:
A:子類中的成員變量和父類中的成員變量名稱不同，這個太簡單。
B:子類中的成員變量和父類中的成員變量名稱同樣，這個怎麼玩呢?
在子類方法中訪問一個變量的查找順序：
a: 在子類方法的局部範圍找，有就使用
b:在子類的成員範圍找，有就使用
c:在父類的成員範圍找，有就使用
d:若是還找不到，就報錯。
*/
class Father {
public int num = 10;
public void method() {
int num = 50;
}
}
class Son extends Father {
public int num2 = 20;
public int num = 30;
public void show() {
int num = 40;
System.out.println(num);
System.out.println(num2);
// 找不到符號
System.out.println(num3);
}
}
class ExtendsDemo4 {
public static void main(String[] args) {
//建立對象
Son s = new Son();
s.show();
}
}
====================================================================/*
問題是：
我不只僅要輸出局部範圍的num，還要輸出本類成員範圍的num。怎麼辦呢?
我還想要輸出父類成員範圍的num。怎麼辦呢?
若是有一個東西和this類似，可是能夠直接訪問父類的數據就行了。
恭喜你，這個關鍵字是存在的：super。
this和super的區別?
分別是什麼呢?
this表明本類對應的引用。
super表明父類存儲空間的標識(能夠理解爲父類引用,能夠操做父類的成員)
怎麼用呢?
A:調用成員變量
this.成員變量 調用本類的成員變量
super.成員變量 調用父類的成員變量
B:調用構造方法
this(...) 調用本類的構造方法
super(...) 調用父類的構造方法
C:調用成員方法
this.成員方法 調用本類的成員方法
super.成員方法 調用父類的成員方法
*/
class Father {
public int num = 10;
}
class Son extends Father {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class ExtendsDemo5 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
====================================================================/*
繼承中構造方法的關係
A:子類中全部的構造方法默認都會訪問父類中空參數的構造方法
B:爲何呢?
由於子類會繼承父類中的數據，可能還會使用父類的數據。
因此，子類初始化以前，必定要先完成父類數據的初始化。
注意：子類每個構造方法的第一條語句默認都是：super();
*/
class Father {
int age;
public Father() {
System.out.println("Father的無參構造方法");
}
public Father(String name) {
System.out.println("Father的帶參構造方法");
}
}
class Son extends Father {
public Son() {
//super();
System.out.println("Son的無參構造方法");
}
public Son(String name) {
//super();
System.out.println("Son的帶參構造方法");
}
}
class ExtendsDemo6 {
public static void main(String[] args) {
//建立對象
Son s = new Son();
System.out.println("------------");
Son s2 = new Son("林青霞");
}
}
====================================================================/*
若是父類沒有無參構造方法，那麼子類的構造方法會出現什麼現象呢?
報錯。
如何解決呢?
A:在父類中加一個無參構造方法
B:經過使用super關鍵字去顯示的調用父類的帶參構造方法
C:子類經過this去調用本類的其餘構造方法
子類中必定要有一個去訪問了父類的構造方法，不然父類數據就沒有初始化。
注意事項：
this(...)或者super(...)必須出如今第一條語句上。
若是不是放在第一條語句上，就可能對父類的數據進行了屢次初始化，因此必須放在第一條語句上。
*/
class Father {
/*
public Father() {
System.out.println("Father的無參構造方法");
}
*/
public Father(String name) {
System.out.println("Father的帶參構造方法");
}
}
class Son extends Father {
public Son() {
super("隨便給");
System.out.println("Son的無參構造方法");
//super("隨便給");
}
public Son(String name) {
//super("隨便給");
this();
System.out.println("Son的帶參構造方法");
}
}
class ExtendsDemo7 {
public static void main(String[] args) {
Son s = new Son();
System.out.println("----------------");
Son ss = new Son("林青霞");
}
}
==================================================
/*
繼承中成員方法的關係:
A:子類中的方法和父類中的方法聲明不同，這個太簡單。
B:子類中的方法和父類中的方法聲明同樣，這個該怎麼玩呢?
經過子類對象調用方法：
a:先找子類中，看有沒有這個方法，有就使用
b:再看父類中，有沒有這個方法，有就使用
c:若是沒有就報錯。
*/
class Father {
public void show() {
System.out.println("show Father");
}
}
class Son extends Father {
public void method() {
System.out.println("method Son");
}
public void show() {
System.out.println("show Son");
}
}
class ExtendsDemo8 {
public static void main(String[] args) {
//建立對象
Son s = new Son();
s.show();
s.method();
//s.fucntion(); //找不到符號
}
}
============================================================
/*
方法重寫：子類中出現了和父類中方法聲明如出一轍的方法。
方法重載：
本類中出現的方法名同樣，參數列表不一樣的方法。與返回值無關。
子類對象調用方法的時候：
先找子類自己，再找父類。
方法重寫的應用：
當子類須要父類的功能，而功能主體子類有本身特有內容時，能夠重寫父類中的方法。
這樣，即沿襲了父類的功能，又定義了子類特有的內容。
案例：
A:定義一個手機類。
B:經過研究，我發明了一個新手機，這個手機的做用是在打完電話後，能夠聽天氣預報。
按照咱們基本的設計，咱們把代碼給寫出來了。
可是呢?咱們又發現新手機應該是手機，因此，它應該繼承自手機。
其實這個時候的設計，並非最好的。
由於手機打電話功能，是手機自己就具有的最基本的功能。
因此，個人新手機是不用在提供這個功能的。
可是，這個時候，打電話功能就沒有了。這個很差。
最終，仍是加上這個功能。因爲它繼承了手機類，因此，咱們就直接使用父類的功能便可。
那麼，如何使用父類的功能呢?經過super關鍵字調用
*/
class Phone {
public void call(String name) {
System.out.println("給"+name+"打電話");
}
}
class NewPhone extends Phone {
public void call(String name) {
//System.out.println("給"+name+"打電話");
super.call(name);
System.out.println("能夠聽天氣預報了");
}
}
class ExtendsDemo9 {
public static void main(String[] args) {
NewPhone np = new NewPhone();
np.call("林青霞");
}
}
============================================================
/*
方法重寫的注意事項
A:父類中私有方法不能被重寫
由於父類私有方法子類根本就沒法繼承
B:子類重寫父類方法時，訪問權限不能更低
最好就一致
C:父類靜態方法，子類也必須經過靜態方法進行重寫
其實這個算不上方法重寫，可是現象確實如此，至於爲何算不上方法重寫，多態中我會講解
子類重寫父類方法的時候，最好聲明如出一轍。
*/
class Father {
//private void show() {}
/*
public void show() {
System.out.println("show Father");
}
*/
void show() {
System.out.println("show Father");
}
/*
public static void method() {
}
*/
public void method() {
}
}
class Son extends Father {
//private void show() {}
/*
public void show() {
System.out.println("show Son");
}
*/
public void show() {
System.out.println("show Son");
}
public static void method() {
}
/*
public void method() {
}
*/
}
class ExtendsDemo10 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
================================================================
/*
看程序寫結果：
A:成員變量 就近原則
B:this和super的問題
this訪問本類的成員
super訪問父類的成員
C:子類構造方法執行前默認先執行父類的無參構造方法
D:一個類的初始化過程
成員變量進行初始化
默認初始化
顯示初始化
構造方法初始化
結果：
fu
zi
30
20
10
*/
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(super.num); //10
}
}
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
=====================================================
/*
看程序寫結果：
A:一個類的靜態代碼塊,構造代碼塊,構造方法的執行流程
靜態代碼塊 > 構造代碼塊 > 構造方法
B:靜態的內容是隨着類的加載而加載
靜態代碼塊的內容會優先執行
C:子類初始化以前先會進行父類的初始化
結果是：
靜態代碼塊Fu
靜態代碼塊Zi
構造代碼塊Fu
構造方法Fu
構造代碼塊Zi
構造方法Zi
*/
class Fu {
static {
System.out.println("靜態代碼塊Fu");
}
{
System.out.println("構造代碼塊Fu");
}
public Fu() {
System.out.println("構造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("靜態代碼塊Zi");
}
{
System.out.println("構造代碼塊Zi");
}
public Zi() {
System.out.println("構造方法Zi");
}
}
class ExtendsTest2 {
public static void main(String[] args) {
Zi z = new Zi();
}
}
==========================================================
/*
學生案例和老師案例講解
學生：
成員變量；姓名，年齡
構造方法：無參，帶參
成員方法：getXxx()/setXxx()
老師：
成員變量；姓名，年齡
構造方法：無參，帶參
成員方法：getXxx()/setXxx()
*/
//定義學生類
class Student {
//姓名
private String name;
//年齡
private int age;
public Student() {
}
public Student(String name,int age) {
this.name = name;
this.age = 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;
}
}
//定義老師類
class Teacher {
//姓名
private String name;
//年齡
private int age;
public Teacher() {
}
public Teacher(String name,int age) {
this.name = name;
this.age = 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;
}
}
class ExtendsTest3 {
public static void main(String[] args) {
//建立學生對象並測試
//方式1
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//方式2
Student s2 = new Student("林青霞",27);
System.out.println(s2.getName()+"---"+s2.getAge());
//對應的老師測試我不想了，留給大家本身練習。
}
}
===================================================================
/*
學生案例和老師案例講解
學生：
成員變量；姓名，年齡
構造方法：無參，帶參
成員方法：getXxx()/setXxx()
老師：
成員變量；姓名，年齡
構造方法：無參，帶參
成員方法：getXxx()/setXxx()
看上面兩個類的成員，發現了不少相同的東西，因此咱們就考慮抽取一個共性的類：
人：
成員變量；姓名，年齡
構造方法：無參，帶參
成員方法：getXxx()/setXxx()
學生 繼承 人
老師 繼承 人
*/
//定義人類
class Person {
//姓名
private String name;
//年齡
private int age;
public Person() {
}
public Person(String name,int age) { //"林青霞",27
this.name = name;
this.age = 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;
}
}
//定義學生類
class Student extends Person {
public Student() {}
public Student(String name,int age) { //"林青霞",27
//this.name = name;
//this.age = age;
super(name,age);
}
}
//定義老師類
class Teacher extends Person {
}
class ExtendsTest4 {
public static void main(String[] args) {
//建立學生對象並測試
//方式1
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//方式2
Student s2 = new Student("林青霞",27);
System.out.println(s2.getName()+"---"+s2.getAge());
//補齊老師類中的代碼並進行測試。
}
}
====================================================================
/*
貓狗案例講解
先找到具體的事物，而後發現具體的事物有共性，才提取出一個父類。
貓：
成員變量：姓名，年齡，顏色
構造方法：無參，帶參
成員方法：
getXxx()/setXxx()
eat()
palyGame()
狗：
成員變量：姓名，年齡，顏色
構造方法：無參，帶參
成員方法：
getXxx()/setXxx()
eat()
lookDoor()
共性：
成員變量：姓名，年齡，顏色
構造方法：無參，帶參
成員方法：
getXxx()/setXxx()
eat()
把共性定義到一個類中，這個類的名字叫：動物。
動物類：
成員變量：姓名，年齡，顏色
構造方法：無參，帶參
成員方法：
getXxx()/setXxx()
eat()
貓：
構造方法：無參，帶參
成員方法：palyGame()
狗：
構造方法：無參，帶參
成員方法：lookDoor()
*/
//定義動物類
class Animal {
//姓名
private String name;
//年齡
private int age;
//顏色
private String color;
public Animal() {}
public Animal(String name,int age,String color) {
this.name = name;
this.age = age;
this.color = color;
}
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 String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat() {
System.out.println("不要睡了,該吃飯了");
}
}
//定義貓類
class Cat extends Animal {
public Cat() {}
public Cat(String name,int age,String color) {
super(name,age,color);
}
public void playGame() {
System.out.println("貓玩英雄聯盟");
}
}
//定義狗類
class Dog extends Animal {
public Dog() {}
public Dog(String name,int age,String color) {
super(name,age,color);
}
public void lookDoor() {
System.out.println("狗看家");
}
}
//測試類
class ExtendsTest5 {
public static void main(String[] args) {
//測試貓
//方式1
Cat c1 = new Cat();
c1.setName("Tom");
c1.setAge(3);
c1.setColor("白色");
System.out.println("貓的名字是："+c1.getName()+";年齡是："+c1.getAge()+";顏色是："+c1.getColor());
c1.eat();
c1.playGame();
System.out.println("---------------");
//方式2
Cat c2 = new Cat("傑瑞",5,"土豪金");
System.out.println("貓的名字是："+c2.getName()+";年齡是："+c2.getAge()+";顏色是："+c2.getColor());
c2.eat();
c2.playGame();
//做業：測試狗
}
}
==============================================================================================================================
/*
看程序寫結果：
A:成員變量的問題
int x = 10; //成員變量是基本類型
Student s = new Student(); //成員變量是引用類型
B:一個類的初始化過程
成員變量的初始化
默認初始化
顯示初始化
構造方法初始化
C:子父類的初始化(分層初始化)
先進行父類初始化，而後進行子類初始化。
結果：
YXYZ
問題：
雖然子類中構造方法默認有一個super()
初始化的時候，不是按照那個順序進行的。
而是按照分層初始化進行的。
它僅僅表示要先初始化父類數據，再初始化子類數據。
*/
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Y {
Y() {
System.out.print("Y");
}
}
public class Z extends X {
Y y = new Y();
Z() {
//super
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}
========================
首先我來寫兩個代碼：
//定義學生類
class Student {
String name;
int age;
public Student(){}
//getXxx()/setXxx()
public void eat() {
System.out.println("吃飯");
}
}
//定義老師類
class Teacher {
String name;
int age;
public Teacher(){}
//getXxx()/setXxx()
public void eat() {
System.out.println("吃飯");
}
}
咱們觀察上面兩個代碼：
發現name，age成員變量，以及getXxx()/setXxx(),還有eat()等都是相同的。
若是咱們後來繼續定義類，舉例：工人類，軍人類。他們是否是也具有這些內容。
那麼，咱們每一次定義這樣的類的時候，都要把這些重複的內容都從新定義一遍。
麻煩不?麻煩。因此，咱們要考慮改進?
如何改進呢?
我這想的：我能不能把這些相同的內容給定義到一個獨立的類中。
而後，讓這多個類和這個獨立的類產生一個關係，有了這個關係後，
這多個類就能夠具有這個獨立的類的功能。
爲了實現這個效果，java就提供了一個技術：繼承。
父親：
4個兒子
繼承怎麼表示呢?繼承的格式是什麼樣子的呢?
class Fu {}
class Zi extends Fu {
}
咱們就回頭修改咱們的代碼：
class Person {
String name;
int age;
public Person(){}
//getXxx()/setXxx()
public void eat() {
System.out.println("吃飯");
}
}
class Student extends Person {
public Student(){}
}
class Teacher extends Person {
public Teacher(){}
}
===============================================================================================
1：方法重寫和方法重載的區別?方法重載能改變返回值類型嗎?
方法重寫：
在子類中，出現和父類中如出一轍的方法聲明的現象。
方法重載：
同一個類中，出現的方法名相同，參數列表不一樣的現象。
方法重載能改變返回值類型，由於它和返回值類型無關。
Override：方法重寫
Overload：方法重載
2：this關鍵字和super關鍵字分別表明什麼?以及他們各自的使用場景和做用。
this:表明當前類的對象引用
super:表明父類存儲空間的標識。(能夠理解爲父類的引用，經過這個東西能夠訪問父類的成員)
場景：
成員變量：
this.成員變量
super.成員變量
構造方法：
this(...)
super(...)
成員方法：
this.成員方法
super.成員方法
三.多態，抽象，接口
/*
final能夠修飾類，方法，變量
特色：
final能夠修飾類，該類不能被繼承。
final能夠修飾方法，該方法不能被重寫。(覆蓋，複寫)
final能夠修飾變量，該變量不能被從新賦值。由於這個變量其實常量。
常量：
A:字面值常量
"hello",10,true
B:自定義常量
final int x = 10;
*/
//final class Fu //沒法從最終Fu進行繼承
class Fu {
public int num = 10;
public final int num2 = 20;
/*
public final void show() {
}
*/
}
class Zi extends Fu {
// Zi中的show()沒法覆蓋Fu中的show()
public void show() {
num = 100;
System.out.println(num);
//沒法爲最終變量num2分配值
//num2 = 200;
System.out.println(num2);
}
}
class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
===============================================================
/*
面試題：final修飾局部變量的問題
基本類型：基本類型的值不能發生改變。
引用類型：引用類型的地址值不能發生改變，可是，該對象的堆內存的值是能夠改變的。
*/
class Student {
int age = 10;
}
class FinalTest {
public static void main(String[] args) {
//局部變量是基本數據類型
int x = 10;
x = 100;
System.out.println(x);
int y = 10;
//沒法爲最終變量y分配值
//y = 100;
System.out.println(y);
System.out.println("--------------");
//局部變量是引用數據類型
Student s = new Student();
System.out.println(s.age);
s.age = 100;
System.out.println(s.age);
System.out.println("--------------");
final Student ss = new Student();
System.out.println(ss.age);
ss.age = 100;
System.out.println(ss.age);
//從新分配內存空間
//沒法爲最終變量ss分配值
//ss = new Student();
//100
100
=================
10
100
10
100
}
}
========================================================================================
/*
final修飾變量的初始化時機
A:被final修飾的變量只能賦值一次。
B:在構造方法完畢前。(非靜態的常量)
*/
class Demo {
//int num = 10;
//final int num2 = 20;
int num;
final int num2;
{
//num2 = 10;
}
public Demo() {
num = 100;
//沒法爲最終變量num2分配值
num2 = 200;
}
}
class FinalTest2 {
public static void main(String[] args) {
Demo d = new Demo();
System.out.println(d.num);
System.out.println(d.num2);
}
}
==============================================
/*
繼承的代碼體現
因爲繼承中方法有一個現象：方法重寫。
因此，父類的功能，就會被子類給覆蓋調。
有些時候，咱們不想讓子類去覆蓋掉父類的功能，只能讓他使用。
這個時候，針對這種狀況，Java就提供了一個關鍵字：final
final:最終的意思。常見的是它能夠修飾類，方法，變量。
*/
class Fu {
public final void show() {
System.out.println("這裏是絕密資源,任何人都不能修改");
}
}
class Zi extends Fu {
// Zi中的show()沒法覆蓋Fu中的show()
public void show() {
System.out.println("這是一堆垃圾");
}
}
class ZiDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
======================================================
/*
多態：同一個對象(事物)，在不一樣時刻體現出來的不一樣狀態。
舉例：
貓是貓，貓是動物。
水(液體，固體，氣態)。
多態的前提：
A:要有繼承關 系。
B:要有方法重寫。
其實沒有也是能夠的，可是若是沒有這個就沒有意義。
動物 d = new 貓();
d.show();
動物 d = new 狗();
d.show();
C:要有父類引用指向子類對象。
父 f = new 子();
用代碼體現一下多態。
多態中的成員訪問特色：
A:成員變量
編譯看左邊，運行看左邊。
B:構造方法
建立子類對象的時候，訪問父類的構造方法，對父類的數據進行初始化。
C:成員方法
編譯看左邊，運行看右邊。
D:靜態方法
編譯看左邊，運行看左邊。
(靜態和類相關，算不上重寫，因此，訪問仍是左邊的)
因爲成員方法存在方法重寫，因此它運行看右邊。
*/
class Fu {
public int num = 100;
public void show() {
System.out.println("show Fu");
}
public static void function() {
System.out.println("function Fu");
}
}
class Zi extends Fu {
public int num = 1000;
public int num2 = 200;
public void show() {
System.out.println("show Zi");
}
public void method() {
System.out.println("method zi");
}
public static void function() {
System.out.println("function Zi");
}
}
class DuoTaiDemo {
public static void main(String[] args) {
//要有父類引用指向子類對象。
//父 f = new 子();
Fu f = new Zi();
System.out.println(f.num);//100
//找不到符號
//System.out.println(f.num2);
f.show();//show zi
//找不到符號
//f.method();
f.function();//function fu
}
}
==========================================================
/*
多態的好處：
A:提升了代碼的維護性(繼承保證)
B:提升了代碼的擴展性(由多態保證)
貓狗案例代碼
*/
class Animal {
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
class Dog extends Animal {
public void eat(){
System.out.println("狗吃肉");
}
public void sleep(){
System.out.println("狗站着睡覺");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("貓吃魚");
}
public void sleep() {
System.out.println("貓趴着睡覺");
}
}
class Pig extends Animal {
public void eat() {
System.out.println("豬吃白菜");
}
public void sleep() {
System.out.println("豬側着睡");
}
}
//針對動物操做的工具類
class AnimalTool {
private AnimalTool(){}
/*
//調用貓的功能
public static void useCat(Cat c) {
c.eat();
c.sleep();
}
//調用狗的功能
public static void useDog(Dog d) {
d.eat();
d.sleep();
}
//調用豬的功能
public static void usePig(Pig p) {
p.eat();
p.sleep();
}
*/
public static void useAnimal(Animal a) {
a.eat();
a.sleep();
}
}
class DuoTaiDemo2 {
public static void main(String[] args) {
//我喜歡貓，就養了一隻
Cat c = new Cat();
c.eat();
c.sleep();
//我很喜歡貓，因此，又養了一隻
Cat c2 = new Cat();
c2.eat();
c2.sleep();
//我特別喜歡貓，又養了一隻
Cat c3 = new Cat();
c3.eat();
c3.sleep();
//...
System.out.println("--------------");
//問題來了,我養了不少只貓，每次建立對象是能夠接受的
//可是呢?調用方法，你不以爲很類似嗎?僅僅是對象名不同。
//咱們準備用方法改進
//調用方式改進版本
//useCat(c);
//useCat(c2);
//useCat(c3);
//AnimalTool.useCat(c);
//AnimalTool.useCat(c2);
//AnimalTool.useCat(c3);
AnimalTool.useAnimal(c);
AnimalTool.useAnimal(c2);
AnimalTool.useAnimal(c3);
System.out.println("--------------");
//我喜歡狗
Dog d = new Dog();
Dog d2 = new Dog();
Dog d3 = new Dog();
//AnimalTool.useDog(d);
//AnimalTool.useDog(d2);
//AnimalTool.useDog(d3);
AnimalTool.useAnimal(d);
AnimalTool.useAnimal(d2);
AnimalTool.useAnimal(d3);
System.out.println("--------------");
//我喜歡寵物豬
//定義一個豬類，它要繼承自動物，提供兩個方法，而且還得在工具類中添加該類方法調用
Pig p = new Pig();
Pig p2 = new Pig();
Pig p3 = new Pig();
//AnimalTool.usePig(p);
//AnimalTool.usePig(p2);
//AnimalTool.usePig(p3);
AnimalTool.useAnimal(p);
AnimalTool.useAnimal(p2);
AnimalTool.useAnimal(p3);
System.out.println("--------------");
//我喜歡寵物狼，老虎，豹子...
//定義對應的類，繼承自動物，提供對應的方法重寫，並在工具類添加方法調用
//前面幾個必須寫，我是沒有意見的
//可是，工具類每次都改，麻煩不
//我就想，你能不能不改了
//太簡單：把全部的動物都寫上。問題是名字是什麼呢?到底哪些須要被加入呢?
//改用另外一種解決方案。
}
/*
//調用貓的功能
public static void useCat(Cat c) {
c.eat();
c.sleep();
}
//調用狗的功能
public static void useDog(Dog d) {
d.eat();
d.sleep();
}
*/
}
====================================================================/*
多態的弊端：
不能使用子類的特有功能。
*/
class Fu {
public void show() {
System.out.println("show fu");
}
}
class Zi extends Fu {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
class DuoTaiDemo3 {
public static void main(String[] args) {
//測試
Fu f = new Zi();
f.show();
//f.method();//不能訪問
}
}
=========================================================
/*
多態的弊端：
不能使用子類的特有功能。
我就想使用子類的特有功能?行不行?
行。
怎麼用呢?
A:建立子類對象調用方法便可。(能夠，可是不少時候不合理。並且，太佔內存了)
B:把父類的引用強制轉換爲子類的引用。(向下轉型)
對象間的轉型問題：
向上轉型：
Fu f = new Zi();
向下轉型：
Zi z = (Zi)f; //要求該f必須是可以轉換爲Zi的。
*/
class Fu {
public void show() {
System.out.println("show fu");
}
}
class Zi extends Fu {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
class DuoTaiDemo4 {
public static void main(String[] args) {
//測試
Fu f = new Zi();
f.show();
//f.method();
//建立子類對象
//Zi z = new Zi();
//z.show();
//z.method();
//你可以把子的對象賦值給父親，那麼我能不能把父的引用賦值給子的引用呢?
//若是能夠，可是以下
Zi z = (Zi)f;
z.show();
z.method();
}
}
===========================================================
多態的問題理解：
class 孔子爹 {
public int age = 40;
public void teach() {
System.out.println("講解JavaSE");
}
}
class 孔子 extends 孔子爹 {
public int age = 20;
public void teach() {
System.out.println("講解論語");
}
public void playGame() {
System.out.println("英雄聯盟");
}
}
//Java培訓特別火,不少人來請孔子爹去講課，這一天孔子爹被請走了
//可是還有人來請，就剩孔子在家，價格還挺高。孔子一想，我是否是能夠考慮去呢?
//而後就穿上爹的衣服，帶上爹的眼睛，粘上爹的鬍子。就開始裝爹
//向上轉型
孔子爹 k爹 = new 孔子();
//到人家那裏去了
System.out.println(k爹.age); //40
k爹.teach(); //講解論語
//k爹.playGame(); //這是兒子才能作的
//講完了，下班回家了
//脫下爹的裝備，換上本身的裝備
//向下轉型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //講解論語
k.playGame(); //英雄聯盟
====================================================================/*
ClassCastException:類型轉換異常
通常在多態的向下轉型中容易出現
*/
class Animal {
public void eat(){}
}
class Dog extends Animal {
public void eat() {}
public void lookDoor() {
}
}
class Cat extends Animal {
public void eat() {
}
public void playGame() {
}
}
class DuoTaiDemo5 {
public static void main(String[] args) {
//內存中的是狗
Animal a = new Dog();
Dog d = (Dog)a;
//內存中是貓
a = new Cat();
Cat c = (Cat)a;
//內存中是貓
Dog dd = (Dog)a; //ClassCastException
}
}
=================================================
/*
多態練習：貓狗案例
*/
class Animal {
public void eat(){
System.out.println("吃飯");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
public void lookDoor() {
System.out.println("狗看門");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("貓吃魚");
}
public void playGame() {
System.out.println("貓捉迷藏");
}
}
class DuoTaiTest {
public static void main(String[] args) {
//定義爲狗
Animal a = new Dog();
a.eat();
System.out.println("--------------");
//還原成狗
Dog d = (Dog)a;
d.eat();
d.lookDoor();
System.out.println("--------------");
//變成貓
a = new Cat();
a.eat();
System.out.println("--------------");
//還原成貓
Cat c = (Cat)a;
c.eat();
c.playGame();
System.out.println("--------------");
//演示錯誤的內容
//Dog dd = new Animal();
//Dog ddd = new Cat();
//ClassCastException
//Dog dd = (Dog)a;
}
}
===============================================
/*
不一樣地方飲食文化不一樣的案例
*/
class Person {
public void eat() {
System.out.println("吃飯");
}
}
class SouthPerson extends Person {
public void eat() {
System.out.println("炒菜,吃米飯");
}
public void jingShang() {
System.out.println("經商");
}
}
class NorthPerson extends Person {
public void eat() {
System.out.println("燉菜,吃饅頭");
}
public void yanJiu() {
System.out.println("研究");
}
}
class DuoTaiTest2 {
public static void main(String[] args) {
//測試
//南方人
Person p = new SouthPerson();
p.eat();
System.out.println("-------------");
SouthPerson sp = (SouthPerson)p;
sp.eat();
sp.jingShang();
System.out.println("-------------");
//北方人
p = new NorthPerson();
p.eat();
System.out.println("-------------");
NorthPerson np = (NorthPerson)p;
np.eat();
np.yanJiu();
}
}
===================================================
/*
看程序寫結果:先判斷有沒有問題，若是沒有，寫出結果
*/
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class DuoTaiTest3 {
public static void main(String[] args) {
Fu f = new Zi();
//找不到符號
//f.method();
f.show(); //zi show
}
}
==========================================================
/*
看程序寫結果:先判斷有沒有問題，若是沒有，寫出結果
多態的成員訪問特色：
方法：編譯看左邊，運行看右邊。
繼承的時候：
子類中有和父類中同樣的方法，叫重寫。
子類中沒有父親中出現過的方法，方法就被繼承過來了。
*/
class A {
public void show() {
show2();
}
public void show2() {
System.out.println("我");
}
}
class B extends A {
/*
public void show() {
show2();
}
*/
public void show2() {
System.out.println("愛");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("你");
}
}
public class DuoTaiTest4 {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}
====================================================================
/*
抽象類的概述：
動物不該該定義爲具體的東西，並且動物中的吃，睡等也不該該是具體的。
咱們把一個不是具體的功能稱爲抽象的功能，而一個類中若是有抽象的功能，該類必須是抽象類。
抽象類的特色：
A:抽象類和抽象方法必須用abstract關鍵字修飾
B:抽象類中不必定有抽象方法,可是有抽象方法的類必須定義爲抽象類
C:抽象類不能實例化 不能建立對象
由於它不是具體的。
抽象類有構造方法，可是不能實例化?構造方法的做用是什麼呢?
用於子類訪問父類數據的初始化
D:抽象的子類
a:若是不想重寫抽象方法，該子類是一個抽象類。
b:重寫全部的抽象方法，這個時候子類是一個具體的類。
抽象類的實例化實際上是靠具體的子類實現的。是多態的方式。
Animal a = new Cat();
*/
//abstract class Animal //抽象類的聲明格式
abstract class Animal {
//抽象方法
//public abstract void eat(){} //空方法體,這個會報錯。抽象方法不能有主體
public abstract void eat();
public Animal(){}
}
//子類是抽象類
abstract class Dog extends Animal {}
//子類是具體類，重寫抽象方法
class Cat extends Animal {
public void eat() {
System.out.println("貓吃魚");
}
}
class AbstractDemo {
public static void main(String[] args) {
//建立對象
//Animal是抽象的; 沒法實例化
//Animal a = new Animal();
//經過多態的方式
Animal a = new Cat();
a.eat();
}
}
====================================================================
/*
抽象類的成員特色：
成員變量：既能夠是變量，也能夠是常量。
構造方法：有。
用於子類訪問父類數據的初始化。
成員方法：既能夠是抽象的，也能夠是非抽象的。
抽象類的成員方法特性：
A:抽象方法 強制要求子類作的事情。
B:非抽象方法 子類繼承的事情，提升代碼複用性。
*/
abstract class Animal {
public int num = 10;
public final int num2 = 20;
public Animal() {}
public Animal(String name,int age){}
public abstract void show();
public void method() {
System.out.println("method");
}
}
class Dog extends Animal {
public void show() {
System.out.println("show Dog");
}
}
class AbstractDemo2 {
public static void main(String[] args) {
//建立對象
Animal a = new Dog();
a.num = 100;
System.out.println(a.num);
//a.num2 = 200;
System.out.println(a.num2);
System.out.println("--------------");
a.show();
a.method();
}
}
==============================================
/*
一個類若是沒有抽象方法，可不能夠定義爲抽象類?若是能夠，有什麼意義?
A:能夠。
B:不讓建立對象。
abstract不能和哪些關鍵字共存?
private 衝突
final 衝突
static 無心義
*/
abstract class Fu {
//public abstract void show();
//非法的修飾符組合: abstract和private
//private abstract void show();
//非法的修飾符組合
//final abstract void show();
//非法的修飾符組合
static abstract void show();
public static void method() {
System.out.println("method");
}
}
class Zi extends Fu {
public void show() {}
}
class AbstractDemo3 {
public static void main(String[] args) {
Fu.method();
}
}
==================================
/*
貓狗案例
具體事物：貓，狗
共性：姓名，年齡，吃飯
分析：從具體到抽象
貓:
成員變量：姓名，年齡
構造方法：無參，帶參
成員方法：吃飯(貓吃魚)
狗:
成員變量：姓名，年齡
構造方法：無參，帶參
成員方法：吃飯(狗吃肉)
由於有共性的內容，因此就提取了一個父類。動物。
可是又因爲吃飯的內容不同，因此吃飯的方法是抽象的，
而方法是抽象的類，類就必須定義爲抽象類。
抽象動物類：
成員變量：姓名，年齡
構造方法：無參，帶參
成員方法：吃飯();
實現：從抽象到具體
動物類:
成員變量：姓名，年齡
構造方法：無參，帶參
成員方法：吃飯();
狗類：
繼承自動物類
重寫吃飯();
貓類：
繼承自動物類
重寫吃飯();
*/
//定義抽象的動物類
abstract class Animal {
//姓名
private String name;
//年齡
private int age;
public Animal() {}
public Animal(String name,int age) {
this.name = name;
this.age = 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;
}
//定義一個抽象方法
public abstract void eat();
}
//定義具體的狗類
class Dog extends Animal {
public Dog() {}
public Dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
}
//定義具體的貓類
class Cat extends Animal {
public Cat() {}
public Cat(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("貓吃魚");
}
}
//測試類
class AbstractTest {
public static void main(String[] args) {
//測試狗類
//具體類用法
//方式1：
Dog d = new Dog();
d.setName("旺財");
d.setAge(3);
System.out.println(d.getName()+"---"+d.getAge());
d.eat();
//方式2：
Dog d2 = new Dog("旺財",3);
System.out.println(d2.getName()+"---"+d2.getAge());
d2.eat();
System.out.println("---------------------------");
Animal a = new Dog();
a.setName("旺財");
a.setAge(3);
System.out.println(a.getName()+"---"+a.getAge());
a.eat();
Animal a2 = new Dog("旺財",3);
System.out.println(a2.getName()+"---"+a2.getAge());
a2.eat();
//練習：測試貓類
}
}
====================================================================
/*
老師案例
具體事物：基礎班老師，就業班老師
共性：姓名，年齡，講課。
分析：
基礎班老師
姓名，年齡
講課。
就業班老師
姓名，年齡
講課。
實現：
老師類
基礎班老師
就業班老師
*/
//定義抽象的老師類
abstract class Teacher {
//姓名
private String name;
//年齡
private int age;
public Teacher() {}
public Teacher(String name,int age) {
this.name = name;
this.age = 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;
}
//抽象方法
public abstract void teach();
}
//基礎班老師類
class BasicTeacher extends Teacher {
public BasicTeacher(){}
public BasicTeacher(String name,int age) {
super(name,age);
}
public void teach() {
System.out.println("基礎班老師講解JavaSE");
}
}
//就業班老師類
class WorkTeacher extends Teacher {
public WorkTeacher(){}
public WorkTeacher(String name,int age) {
super(name,age);
}
public void teach() {
System.out.println("就業班老師講解JavaEE");
}
}
class AbstractTest2 {
public static void main(String[] args) {
//具體的類測試，本身玩
//測試(多態)
//基礎班老師
Teacher t = new BasicTeacher();
t.setName("劉意");
t.setAge(30);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
System.out.println("--------------");
t = new BasicTeacher("劉意",30);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
System.out.println("--------------");
//就業班老師
t = new WorkTeacher();
t.setName("林青霞");
t.setAge(27);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
System.out.println("--------------");
t = new WorkTeacher("林青霞",27);
System.out.println(t.getName()+"---"+t.getAge());
t.teach();
}
}
==========================================================
/*
學生案例
具體事務：基礎班學員，就業班學員
共性：姓名，年齡，班級，學習，吃飯
分析：
基礎班學員
成員變量：姓名，年齡，班級
成員方法：學習，吃飯
就業班學員
成員變量：姓名，年齡，班級
成員方法：學習，吃飯
獲得一個學員類。
成員變量：姓名，年齡，班級
成員方法：學習，吃飯
實現：
學員類
基礎班學員
就業班學員
*/
//定義抽象學員類
abstract class Student {
//姓名
private String name;
//年齡
private int age;
//班級
private String grand;
public Student() {}
public Student(String name,int age,String grand) {
this.name = name;
this.age = age;
this.grand = grand;
}
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 String getGrand() {
return grand;
}
public void setGrand(String grand) {
this.grand = grand;
}
//學習
public abstract void study();
//吃飯
public void eat() {
System.out.println("學習累了,就該吃飯");
}
}
//具體基礎班學員類
class BasicStudent extends Student {
public BasicStudent() {}
public BasicStudent(String name,int age,String grand) {
super(name,age,grand);
}
public void study() {
System.out.println("基礎班學員學習的是JavaSE");
}
}
//具體就業班學員類
class WorkStudent extends Student {
public WorkStudent() {}
public WorkStudent(String name,int age,String grand) {
super(name,age,grand);
}
public void study() {
System.out.println("就業班學員學習的是JavaEE");
}
}
class AbstractTest3 {
public static void main(String[] args) {
//我僅僅測試基礎班學員
//按照多態的方式測試
Student s = new BasicStudent();
s.setName("林青霞");
s.setAge(27);
s.setGrand("1111");
System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
s.study();
s.eat();
System.out.println("--------------");
s = new BasicStudent("武鑫",48,"1111");
System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
s.study();
s.eat();
//就業班測試留給本身玩
}
}
====================================================================/*
假如咱們在開發一個系統時須要對員工類進行設計，員工包含3個屬性：姓名、工號以及工資。
經理也是員工，除了含有員工的屬性外，另爲還有一個獎金屬性。
請使用繼承的思想設計出員工類和經理類。要求類中提供必要的方法進行屬性訪問。
分析：
普通員工類
成員變量：姓名、工號以及工資。
成員方法：工做
經理類：
成員變量：姓名、工號以及工資，獎金屬性
成員方法：工做
實現：
員工類：
普通員工類：
經理類：
*/
//定義員工類
abstract class Employee {
//姓名、工號以及工資
private String name;
private String id;
private int salary;
public Employee() {}
public Employee(String name,String id,int salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
//工做
public abstract void work();
}
//普通員工類
class Programmer extends Employee {
public Programmer(){}
public Programmer(String name,String id,int salary) {
super(name,id,salary);
}
public void work() {
System.out.println("按照需求寫代碼");
}
}
//經理類
class Manager extends Employee {
//獎金
private int money; //bonus 獎金
public Manager(){}
public Manager(String name,String id,int salary,int money) {
super(name,id,salary);
this.money = money;
}
public void work() {
System.out.println("跟客戶談需求");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
class AbstractTest4 {
public static void main(String[] args) {
//測試普通員工
Employee emp = new Programmer();
emp.setName("林青霞");
emp.setId("czbk001");
emp.setSalary(18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
emp = new Programmer("林青霞","czbk001",18000);
System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
emp.work();
System.out.println("-------------");
/*
emp = new Manager();
emp.setName("劉意");
emp.setId("czbk002");
emp.setSalary(8000);
emp.setMoney(2000);
*/
//因爲子類有特有的內容，因此咱們用子類來測試
Manager m = new Manager();
m.setName("劉意");
m.setId("czbk002");
m.setSalary(8000);
m.setMoney(2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
System.out.println("-------------");
//經過構造方法賦值
m = new Manager("劉意","czbk002",8000,2000);
System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
m.work();
}
}
====================================================================
/*
接口的特色：
A:接口用關鍵字interface表示
interface 接口名 {}
B:類實現接口用implements表示
class 類名 implements 接口名 {}
C:接口不能實例化
那麼，接口如何實例化呢?
按照多態的方式來實例化。
D:接口的子類
a:能夠是抽象類。可是意義不大。
b:能夠是具體類。要重寫接口中的全部抽象方法。(推薦方案)
因而可知：
A:具體類多態(幾乎沒有)
B:抽象類多態(經常使用)
C:接口多態(最經常使用)
*/
//定義動物培訓接口
interface AnimalTrain {
public abstract void jump();
}
//抽象類實現接口
abstract class Dog implements AnimalTrain {
}
//具體類實現接口
class Cat implements AnimalTrain {
public void jump() {
System.out.println("貓能夠跳高了");
}
}
class InterfaceDemo {
public static void main(String[] args) {
//AnimalTrain是抽象的; 沒法實例化
//AnimalTrain at = new AnimalTrain();
//at.jump();
AnimalTrain at = new Cat();
at.jump();
}
}
==========================================
/*
接口成員特色
成員變量；只能是常量，而且是靜態的。
默認修飾符：public static final
建議：本身手動給出。
構造方法：接口沒有構造方法。
成員方法：只能是抽象方法。
默認修飾符：public abstract
建議：本身手動給出。
全部的類都默認繼承自一個類：Object。
類 Object 是類層次結構的根類。每一個類都使用 Object 做爲超類。
*/
interface Inter {
public int num = 10;
public final int num2 = 20;
public static final int num3 = 30;
//錯誤: 須要<標識符>
//public Inter() {}
//接口方法不能帶有主體
//public void show() {}
//abstract void show(); //默認public
public void show(); //默認abstract
}
//接口名+Impl這種格式是接口的實現類格式
/*
class InterImpl implements Inter {
public InterImpl() {
super();
}
}
*/
class InterImpl extends Object implements Inter {
public InterImpl() {
super();
}
public void show() {}
}
//測試類
class InterfaceDemo2 {
public static void main(String[] args) {
//建立對象
Inter i = new InterImpl();
System.out.println(i.num);
System.out.println(i.num2);
//i.num = 100;
//i.num2 = 200;
//System.out.println(i.num); //沒法爲最終變量num分配值
//System.out.println(i.num2);//沒法爲最終變量num2分配值
System.out.println(Inter.num);
System.out.println(Inter.num2);
System.out.println("--------------");
}
}
==========================================================
/*
類與類：
繼承關係,只能單繼承,能夠多層繼承。
類與接口：
實現關係,能夠單實現,也能夠多實現。
而且還能夠在繼承一個類的同時實現多個接口。
接口與接口：
繼承關係,能夠單繼承,也能夠多繼承。
*/
interface Father {
public abstract void show();
}
interface Mother {
public abstract void show2();
}
interface Sister extends Father,Mother {
}
//class Son implements Father,Mother //多實現
class Son extends Object implements Father,Mother {
public void show() {
System.out.println("show son");
}
public void show2() {
System.out.println("show2 son");
}
}
class InterfaceDemo3 {
public static void main(String[] args) {
//建立對象
Father f = new Son();
f.show();
//f.show2(); //報錯
Mother m = new Son();
//m.show(); //報錯
m.show2();
}
}
====================================================================/*
貓狗案例,加入跳高的額外功能
分析：從具體到抽象
貓：
姓名,年齡
吃飯，睡覺
狗：
姓名,年齡
吃飯，睡覺
因爲有共性功能，因此，咱們抽取出一個父類：
動物：
姓名,年齡
吃飯();
睡覺(){}
貓：繼承自動物
狗：繼承自動物
跳高的額外功能是一個新的擴展功能，因此咱們要定義一個接口
接口：
跳高
部分貓：實現跳高
部分狗：實現跳高
實現；
從抽象到具體
使用：
使用具體類
*/
//定義跳高接口
interface Jumpping {
//跳高功能
public abstract void jump();
}
//定義抽象類
abstract class Animal {
//姓名
private String name;
//年齡
private int age;
public Animal() {}
public Animal(String name,int age) {
this.name = name;
this.age = 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;
}
//吃飯();
public abstract void eat();
//睡覺(){}
public void sleep() {
System.out.println("睡覺覺了");
}
}
//具體貓類
class Cat extends Animal {
public Cat(){}
public Cat(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("貓吃魚");
}
}
//具體狗類
class Dog extends Animal {
public Dog(){}
public Dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
}
//有跳高功能的貓
class JumpCat extends Cat implements Jumpping {
public JumpCat() {}
public JumpCat(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高貓");
}
}
//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
public JumpDog() {}
public JumpDog(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高狗");
}
}
class InterfaceTest {
public static void main(String[] args) {
//定義跳高貓並測試
JumpCat jc = new JumpCat();
jc.setName("哆啦A夢");
jc.setAge(3);
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("-----------------");
JumpCat jc2 = new JumpCat("加菲貓",2);
System.out.println(jc2.getName()+"---"+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
//定義跳高狗並進行測試的事情本身完成。
}
}
===================================================================
/*
老師和學生案例,加入抽菸的額外功能
分析：從具體到抽象
老師：姓名，年齡，吃飯，睡覺
學生：姓名，年齡，吃飯，睡覺
因爲有共性功能，咱們提取出一個父類，人類。
人類：
姓名，年齡
吃飯();
睡覺(){}
抽菸的額外功能不是人或者老師，或者學生一開始就應該具有的，因此，咱們把它定義爲接口
抽菸接口。
部分老師抽菸：實現抽菸接口
部分學生抽菸：實現抽菸接口
實現：從抽象到具體
使用：具體
*/
//定義抽菸接口
interface Smoking {
//抽菸的抽象方法
public abstract void smoke();
}
//定義抽象人類
abstract class Person {
//姓名
private String name;
//年齡
private int age;
public Person() {}
public Person(String name,int age) {
this.name = name;
this.age = 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;
}
//吃飯();
public abstract void eat();
//睡覺(){}
public void sleep() {
System.out.println("睡覺覺了");
}
}
//具體老師類
class Teacher extends Person {
public Teacher() {}
public Teacher(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("吃大白菜");
}
}
//具體學生類
class Student extends Person {
public Student() {}
public Student(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("吃紅燒肉");
}
}
//抽菸的老師
class SmokingTeacher extends Teacher implements Smoking {
public SmokingTeacher() {}
public SmokingTeacher(String name,int age) {
super(name,age);
}
public void smoke() {
System.out.println("抽菸的老師");
}
}
//抽菸的學生
class SmokingStudent extends Student implements Smoking {
public SmokingStudent() {}
public SmokingStudent(String name,int age) {
super(name,age);
}
public void smoke() {
System.out.println("抽菸的學生");
}
}
class InterfaceTest2 {
public static void main(String[] args) {
//測試學生
SmokingStudent ss = new SmokingStudent();
ss.setName("林青霞");
ss.setAge(27);
System.out.println(ss.getName()+"---"+ss.getAge());
ss.eat();
ss.sleep();
ss.smoke();
System.out.println("-------------------");
SmokingStudent ss2 = new SmokingStudent("劉意",30);
System.out.println(ss2.getName()+"---"+ss2.getAge());
ss2.eat();
ss2.sleep();
ss2.smoke();
//測試老師留給本身練習
}
}
====================================================================抽象類和接口的區別：
A:成員區別
抽象類：
成員變量：能夠變量，也能夠常量
構造方法：有
成員方法：能夠抽象，也能夠非抽象
接口：
成員變量：只能夠常量
成員方法：只能夠抽象
B:關係區別
類與類
繼承，單繼承
類與接口
實現，單實現，多實現
接口與接口
繼承，單繼承，多繼承
C:設計理念區別
抽象類 被繼承體現的是：」is a」的關係。抽象類中定義的是該繼承體系的共性功能。
接口 被實現體現的是：」like a」的關係。接口中定義的是該繼承體系的擴展功能。
四.匿名內部類
package cn.itcast_03;
import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;
/*
* 經常使用快捷鍵
* 1:格式化 ctrl+shift+f
* 2：導入包 ctrl+shift+o
* 若是該類僅僅在一個包中有，就本身顯示了
* 若是該類在多個包中有，會彈出一個框框供你選擇
* 3:註釋
* 單行：註釋 ctrl+/，取消註釋再來一次。
* 多行：ctrl+shift+/,ctrl+shift+\
* 4:代碼上下移動
* 選中代碼alt+上/下箭頭
* 5:查看源碼
* 選中類名(F3或者Ctrl+鼠標點擊)
*/
public class HelloWorld {
public static void main(String[] args) {
int a = 10;
System.out.println(a);
Scanner sc = new Scanner(System.in);
Date d = new Date();
// StringBuffer
// ArrayList<E>
Math.random();
}
}
============================================================
package cn.itcast_03;
import cn.itcast_01.HelloWorld;
/*
* alt+/ 內容輔助鍵
*
* A:main方法
* main+alt+/ 回車便可
* B:輸出語句
* syso+alt+/
* C:提示做用
* 幫助你補齊一些你你不住的東西，還能夠幫你起名字等。
*/
public class Demo {
// public static void main(String[] args) {
// System.out.println("HelloWorld");
// }
public static void main(String[] args) {
System.out.println();
String string = new String();
HelloWorld helloWorld = new HelloWorld();
}
}
=============================================================
package cn.itcast_04;
/*
* 提升開發效率：
* A:幫助咱們自動提供構造方法
a:無參構造方法
在代碼區域右鍵--source--Generate Constructors from Superclass
b:帶參構造方法
在代碼區域右鍵--source--Generate Constructors using fields.. -- finish
B:成對的getXxx()和setXxx()
在代碼區域右鍵--source--Generate Getters and Setters...
*/
public class Student {
// 成員變量
private String name;
private int age;
//構造方法
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = 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;
}
}
==========================================
package cn.itcast_04;
public class Teacher {
// 成員變量
private String name;
private int age;
public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
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;
}
}
=====================================
package cn.itcast_01;
public class Student {
// 姓名
private String name;
// 年齡
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
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 void show() {
System.out.println("姓名：" + name + ",年齡:" + age);
}
}
package cn.itcast_01;
/*
* 測試類
*/
public class StudentDemo {
public static void main(String[] args) {
// 建立對象
Student s1 = new Student();
s1.setName("風清揚");
s1.setAge(30);
System.out.println(s1.getName() + "---" + s1.getAge());
s1.show();
// 建立對象
Student s2 = new Student("林青霞", 27);
System.out.println(s2.getName() + "---" + s2.getAge());
s2.show();
}
}
========================================================
package cn.itcast_03;
/*
* 經過debug查看程序執行流程
* 請你們也作一遍。 F6執行下一步
*/
public class ArgsDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:" + a + ",b:" + b);
change(a, b);
System.out.println("a:" + a + ",b:" + b);
int[] arr = { 1, 2, 3, 4, 5 };
change(arr);
System.out.println(arr[1]);
}
public static void change(int a, int b) {
System.out.println("a:" + a + ",b:" + b);
a = b;
b = a + b;
System.out.println("a:" + a + ",b:" + b);
}
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
======================================
package cn.itcast_01;
/*
* Object:類 Object 是類層次結構的根類。每一個類都使用 Object 做爲超類。
* 每一個類都直接或者間接的繼承自Object類。
*
* Object類的方法：
* public int hashCode():返回該對象的哈希碼值。
* 注意：哈希值是根據哈希算法計算出來的一個值，這個值和地址值有關，可是不是實際地址值。
* 你能夠理解爲地址值。
*
* public final Class getClass():返回此 Object 的運行時類
* Class類的方法：
* public String getName()：以 String 的形式返回此 Class 對象所表示的實體
*/
public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.hashCode()); // 11299397
Student s2 = new Student();
System.out.println(s2.hashCode());// 24446859
Student s3 = s1;
System.out.println(s3.hashCode()); // 11299397
System.out.println("-----------");
Student s = new Student();
Class c = s.getClass();
String str = c.getName();
System.out.println(str); // cn.itcast_01.Student
//鏈式編程
String str2 = s.getClass().getName();
System.out.println(str2);
}
}
====================================================================
package cn.itcast_02;
/*
* public String toString():返回該對象的字符串表示。
*
* Integer類下的一個靜態方法：
* public static String toHexString(int i)：把一個整數轉成一個十六進制表示的字符串
*
* 這個信息的組成咱們講解完畢了，可是這個信息是沒有任何意義的。因此，建議全部子類都重寫該方法。
* 怎麼重寫呢?
* 把該類的全部成員變量值組成返回便可。
* 重寫的最終版方案就是自動生成toString()方法。
*
* 注意：
* 直接輸出一個對象的名稱，其實就是調用該對象的toString()方法。
*/
public class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.hashCode());
System.out.println(s.getClass().getName());
System.out.println("--------------------");
System.out.println(s.toString());// cn.itcast_02.Student@42552c
System.out.println("--------------------");
// toString()方法的值等價於它
// getClass().getName() + '@' + Integer.toHexString(hashCode())
// this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())
// cn.itcast_02.Student@42552c
// cn.itcast_02.Student@42552c
System.out.println(s.getClass().getName() + '@'
+ Integer.toHexString(s.hashCode()));
System.out.println(s.toString());
// 直接輸出對象的名稱
System.out.println(s); // cn.itcast_02.Student@42552c
}
}
============================================================
package cn.itcast_03;
/*
* public boolean equals(Object obj):指示其餘某個對象是否與此對象「相等」。
* 這個方法，默認狀況下比較的是地址值。比較地址值通常來講意義不大，因此咱們要重寫該方法。
* 怎麼重寫呢?
* 通常都是用來比較對象的成員變量值是否相同。
* 重寫的代碼優化：提升效率，提升程序的健壯性。
* 最終版：
* 其實仍是自動生成。
*
* 看源碼：
* public boolean equals(Object obj) {
* //this - s1
* //obj - s2
* return (this == obj);
* }
*
* ==:
* 基本類型：比較的就是值是否相同
* 引用類型：比較的就是地址值是否相同
* equals:
* 引用類型：默認狀況下，比較的是地址值。
* 不過，咱們能夠根據狀況本身重寫該方法。通常重寫都是自動生成，比較對象的成員變量值是否相同
*/
public class StudentDemo {
public static void main(String[] args) {
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("林青霞", 27);
System.out.println(s1 == s2); // false
Student s3 = s1;
System.out.println(s1 == s3);// true
System.out.println("---------------");
System.out.println(s1.equals(s2)); // obj = s2; //false
System.out.println(s1.equals(s1)); // true
System.out.println(s1.equals(s3)); // true
Student s4 = new Student("風清揚",30);
System.out.println(s1.equals(s4)); //false
Demo d = new Demo();
System.out.println(s1.equals(d)); //ClassCastException
}
}
class Demo {}
package cn.itcast_03;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = 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;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
// @Override
// public boolean equals(Object obj) {
// // return true;
// //這裏要改進，根據這裏比較的成員變量來決定返回true仍是false
// //這裏其實要比價的就是name和age
// //可是，name是String類型的，而String是引用類型的，因此，在這裏不能直接用==比較，應該用equals()比較
// //String的equals()方法是重寫自Object類的，比較的是字符串的內容是否相同
// //this -- s1
// //obj -- s2
// //咱們要使用的是學生類的特有成員變量,因此要向下轉型
// Student s = (Student)obj; //s -- obj -- s2;
// if(this.name.equals(s.name) && this.age == s.age) {
// return true;
// }else {
// return false;
// }
// }
// @Override
// public boolean equals(Object obj) {
// //爲了提升效率
// if(this == obj){
// return true;
// }
//
// //爲了提供程序的健壯性
// //我先判斷一下，obj是否是學生的一個對象，若是是，再作向下轉型，若是不是，直接返回false。
// //這個時候，咱們要判斷的是對象是不是某個類的對象?
// //記住一個格式：對象名 instanceof 類名
// //表示：判斷該對象名是不是該類名一個對象
// if(!(obj instanceof Student)){
// return false;
// }
// //若是是就繼續
//
// Student s = (Student)obj;
// //System.out.println("同一個對象，還須要向下轉型並比較嗎?");
// return this.name.equals(s.name) && this.age == s.age;
// }
}
===========================================================================
package cn.itcast_04;
*
* Cloneable:此類實現了 Cloneable 接口，以指示 Object.clone() 方法能夠合法地對該類實例進行按字段複製。
* 這個接口是標記接口，告訴咱們實現該接口的類就能夠實現對象的複製了。
*/
public class StudentDemo {
public static void main(String[] args) throws CloneNotSupportedException {
//建立學生對象
Student s = new Student();
s.setName("林青霞");
s.setAge(27);
//克隆學生對象
Object obj = s.clone();
Student s2 = (Student)obj;
System.out.println("---------");
System.out.println(s.getName()+"---"+s.getAge());
System.out.println(s2.getName()+"---"+s2.getAge());
//之前的作法
Student s3 = s;
System.out.println(s3.getName()+"---"+s3.getAge());
System.out.println("---------");
//實際上是有區別的
s3.setName("劉意");
s3.setAge(30);
System.out.println(s.getName()+"---"+s.getAge());
System.out.println(s2.getName()+"---"+s2.getAge());
System.out.println(s3.getName()+"---"+s3.getAge());
}
}
package cn.itcast_04;
public class Student implements Cloneable {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = 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;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
===========================================================================
1:Eclipse的安裝
2:用Eclipse寫一個HelloWorld案例，最終在控制檯輸出你的名字
A:建立項目
B:在src目錄下建立包。cn.itcast
C:在cn.itcast包下建立類。HelloWorld
D:在HelloWorld下有一個方法。public static void main(String[] args) {}
E:在main方法中有一個輸出語句。System.out.println("你的名字");
3:Eclipse空間的基本配置
A:程序的編譯和運行的環境配置(通常不改)
window -- Preferences -- Java
編譯環境：Compiler 默認選中的就是最高版本。
運行環境：Installed JREs 默認會找你安裝的那個JDK。建議配置了Java的環境變量。
問題：
低編譯，高運行。能夠。
高編譯，低運行。不能夠。
建議，編譯和運行的版本一致。
B:如何去掉默認註釋?
window -- Preferences -- Java -- Code Style -- Code Templates
選擇你不想要的內容，經過右邊Edit編輯。
注意：請只刪除註釋部分，不是註釋部分的不要刪除。
C:行號的顯示和隱藏
顯示：在代碼區域的最左邊的空白區域，右鍵 -- Show Line Numbers便可。
隱藏：把上面的動做再作一次。
D:字體大小及顏色
a:Java代碼區域的字體大小和顏色：
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java修改 -- Java Edit Text Font
b:控制檯
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
c:其餘文件
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
E:窗體給弄亂了，怎麼辦?
window -- Reset Perspective
F:控制檯找不到了，怎麼辦?
Window--Show View—Console
4:經常使用快捷鍵
A:格式化 ctrl+shift+f
B:導入包 ctrl+shift+o
若是該類僅僅在一個包中有，就本身顯示了
若是該類在多個包中有，會彈出一個框框供你選擇
C:註釋
單行：註釋 ctrl+/，取消註釋再來一次。
多行：ctrl+shift+/,ctrl+shift+\
D:代碼上下移動
選中代碼alt+上/下箭頭
E:查看源碼
選中類名(F3或者Ctrl+鼠標點擊)
5:如何提升開發效率
A:自動生成構造方法
a:無參構造方法 在代碼區域右鍵--source--Generate Constructors from Superclass
b:帶參構造方法 在代碼區域右鍵--source--Generate Constructors using fields.. -- finish
B:自動生成getXxx()/setXxx()方法
在代碼區域右鍵--source--Generate Getters and Setters...
提供了對應的快捷鍵操做。
alt+shift+s
按下帶有下劃線的那個字母便可。
C:如何繼承抽象類和實現接口。
D:Override的做用
表示該方法是重寫父類的。若是方法聲明和父類不匹配，就會報錯。
6:經過講解的快捷鍵和提升開發效率的一些內容完成以下內容
自定義學生類:Student
成員變量；
姓名
年齡
構造方法：
無參
帶參
成員方法：
getXxx()/setXxx()
在給出一個show()方法，顯示類的全部成員信息。
而後，寫一個測試類，對學生的代碼進行測試。
StudentDemo
7:刪除項目和導入項目
刪除項目
選中項目 – 右鍵 – 刪除
從項目區域中刪除
從硬盤上刪除
導入項目
在項目區域右鍵找到import
找到General，展開，並找到
Existing Projects into Workspace
點擊next,而後選擇你要導入的項目
注意：這裏選擇的是項目名稱
8:要注意的幾個小問題
如何查看項目所在路徑
選中 -- 右鍵 -- Properties -- Resource -- Location
導入項目要注意的問題
項目區域中不可能出現同名的項目(新建或者導入)
本身隨意創建的文件夾是不能做爲項目導入的
修改項目問題
不要隨意修改項目名稱
若是真要修改，不要忘記了配置文件.project中的
<name>把這裏改成你改後的名稱</name>
9:你們接收文件的注意事項
A:專門創建一個文件夾用於接收項目，不要隨意放置。
B:同一個項目再次接收的時候，先去存放目錄把原始項目刪除，而後從新存儲，最後刷新項目便可。
C:天天對照我寫的項目，本身也建立一個練習項目
舉例：個人項目名稱 day11_eclipse
你就建立一個項目名稱 day11_eclipse_test
10:Eclipse中代碼的高級(Debug)調試
做用：
調試程序
查看程序執行流程
如何查看程序執行流程
要想看程序流程，就必須設置斷點。
什麼是斷點：
就是一個標記，從哪裏開始。
如何設置斷點：
你想看哪裏的程序，你就在那個有效程序的左邊雙擊便可。
在哪裏設置斷點：
哪裏不會點哪裏。
目前：咱們就在每一個方法的第一條有效語句上都加。
如何運行設置斷點後的程序：
右鍵 -- Debug as -- Java Application
看哪些地方：
Debug：斷點測試的地方
在這個地方，記住F6，或者點擊也能夠。一次看一行的執行過程。
Variables：查看程序的變量變化
ForDemo：被查看的源文件
Console：控制檯
如何去斷點：
a:再次雙擊便可
b:找到Debug視圖，Variables界面，找到Breakpoints，並點擊，而後看到全部的斷點，最後點擊那個雙叉。
相關文章
- 1. Java基礎(面向對象,繼承,抽象類,接口,多態)
- 2. java 面對對象（抽象 繼承 接口 多態）
- 3. 面向對象——OOP（二）（封裝、繼承、多態、抽象、接口）
- 4. 面向對象（繼承、多態、接口）
- 5. Java面向對象筆記（封裝、繼承、多態、抽象類、接口）
- 6. Java面向對象、抽象、封裝、繼承、多態
- 7. Java基礎——面向對象：抽象，封裝，繼承，多態
- 8. java面向對象概念:抽象、封裝、繼承和多態
- 9. Java面向對象、繼承、多態…
- 10. Java面向對象，繼承，多態
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • IntelliJ IDEA代碼格式化設置
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
