挖穿Android第九天

原創 __ziyang 2020-05-31 14:48

09.01_面向對象(多態的概述及其代碼體現)

  • A:多態(polymorphic [,pɒlɪ’mɔːfɪk])概述
    • 事物存在的多種形態
  • B:多態前提
    • a:要有繼承關係。
    • b:要有方法重寫。
    • c:要有父類引用指向子類對象。
  • C:案例演示
    • 代碼體現多態
      案例：
class Demo1_Polymorphic {
	public static void main(String[] args) {
		Cat c = new Cat();//貓是一隻貓
		c.eat();

		Animal a = new Cat();				//父類引用指向子類對象，貓是一隻動物
		a.eat();
	}
}
class Animal {
	public void eat() {
		System.out.println("動物吃飯");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("貓吃魚");
	}
}

09.02_面向對象(多態中的成員訪問特點之成員變量)

  • 成員變量
    • 編譯看左邊(父類)，運行看左邊(父類)。
      案例：
class Demo2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son();					//父類引用指向子類對象
		System.out.println(f.num);			//相當於是Father.method()
      Son s = new Son();
      System.out.println(s.num);
	}
}
class Father {
	int num = 10;	
}

class Son extends Father {
	int num = 20;
}

在這裏插入圖片描述

09.03_面向對象(多態中的成員訪問特點之成員方法)

  • 成員方法
    • 編譯看左邊(父類)，運行看右邊(子類)。
      案例：
class Demo2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son();
		f.print();							//相當於是Father.method()
	}
}
class Father {
	int num = 10;
	public void print() {
		System.out.println("father");
	}
}

class Son extends Father {
	int num = 20;
	public void print() {
		System.out.println("son");
	}
}

在這裏插入圖片描述

09.04_面向對象(多態中的成員訪問特點之靜態成員方法)

  • 靜態方法
    • 編譯看左邊(父類)，運行看左邊(父類)。
    • (靜態和類相關，算不上重寫，所以，訪問還是左邊的)
    • 只有非靜態的成員方法,編譯看左邊,運行看右邊
      案例：
class Demo2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son();		
		f.method();							//相當於是Father.method()
	}
}
class Father {
	int num = 10;
	public static void method() {
		System.out.println("father static method");
	}
}

class Son extends Father {
	int num = 20;
	public static void method() {
		System.out.println("son static method");
	}
}

09.05_面向對象(超人的故事)

  • A:案例分析
    • 通過該案例幫助學生理解多態的現象（talkTrade:談生意）
      案例：
class Demo3_SuperMan {
	public static void main(String[] args) {
		Person p = new SuperMan();         		//父類引用指向子類對象,超人提升爲了人
											//父類引用指向子類對象就是向上轉型
		System.out.println(p.name);		
                p.talkTrade();
	}
}
class Person {
	String name = "John";
	public void talkTrade() {
		System.out.println("談生意");
	}
}
class SuperMan extends Person {
	String name = "superMan";

	public void talkTrade() {
		System.out.println("談幾個億的大單子");
	}

	public void fly() {
		System.out.println("飛出去救人");
	}
}

09.06_面向對象(多態中向上轉型和向下轉型)

  • A:案例演示
    • 詳細講解多態中向上轉型和向下轉型
      Person p = new SuperMan();向上轉型
      SuperMan sm = (SuperMan)p;向下轉型
      案例：
class Demo3_SuperMan {
	public static void main(String[] args) {
	Person p = new SuperMan();			//父類引用指向子類對象,超人提升爲了人
											//父類引用指向子類對象就是向上轉型
		System.out.println(p.name);
		p.talkTrade();
		SuperMan sm = (SuperMan)p;			//向下轉型
		sm.fly();

		/*
		基本數據類型自動類型提升和強制類型轉換
		*/
		int i = 10;
		byte b = 20;
		//i = b;						//自動類型提升
		//b = (byte)i;					//強制類型轉換
	}
}

class Person {
	String name = "John";
	public void talkTrade() {
		System.out.println("談生意");
	}
}

class SuperMan extends Person {
	String name = "superMan";

	public void talkTrade() {
		System.out.println("談幾個億的大單子");
	}

	public void fly() {
		System.out.println("飛出去救人");
	}
}

在這裏插入圖片描述

09.07_面向對象(多態的好處和弊端)

  • A:多態的好處
    • a:提高了代碼的維護性(繼承保證)
    • b:提高了代碼的擴展性(由多態保證)
  • B:案例演示
    • 多態的好處
    • 可以當作形式參數,可以接收任意子類對象
  • C:多態的弊端
    • 不能使用子類的特有屬性和行爲。
  • D:案例演示
    案例：
class Demo4_Animal {
	public static void main(String[] args) {
		//Cat c1 = new Cat();
		//c1.eat();
		method(new Cat());
		method(new Dog());

		//Animal a = new Cat();			開發的是很少在創建對象的時候用父類引用指向子類對象,直接創建子類對象更方便,可以使用子類中的特有屬性和行爲
	}
	
	//Cat c = new Dog();狗是一隻貓,這是錯誤的
	/*public static void method(Cat c) {			
		c.eat();
	}

	public static void method(Dog d) {
		d.eat();
	}*/
	
	//如果把狗強轉成貓就會出現類型轉換異常,ClassCastException
	public static void method(Animal a) {	//當作參數的時候用多態最好,因爲擴展性強
		//關鍵字 instanceof 判斷前邊的引用是否是後邊的數據類型
		if (a instanceof Cat) {
			Cat c = (Cat)a;
			c.eat();
			c.catchMouse();
		}else if (a instanceof Dog) {
			Dog d = (Dog)a;
			d.eat();
			d.lookHome();
		}else {
			a.eat();
		}
	}
}
class Animal {
	public void eat() {
		System.out.println("動物吃飯");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("貓吃魚");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}

	public void lookHome() {
		System.out.println("看家");
	}
}

09.08_面向對象(多態中的題目分析題)

  • A:看下面程序是否有問題，如果沒有，說出結果
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 Test1Demo {
			public static void main(String[] args) {
				Fu f = new Zi();
				f.method();
				f.show();
			}
		}
  • B:看下面程序是否有問題，如果沒有，說出結果
class A {
			public void show() {
				show2();
			}
			public void show2() {
				System.out.println("我");
			}
		}
		class B extends A {
			public void show2() {
				System.out.println("愛");
			}
		}
		class C extends B {
			public void show() {
				super.show();
			}
			public void show2() {
				System.out.println("你");
			}
		}
		public class Test2DuoTai {
			public static void main(String[] args) {
				A a = new B();
				a.show();//愛
				
				B b = new C();
				b.show();//你
			}
		}

09.09_面向對象(抽象類的概述及其特點)

  • A:抽象類概述
    • 抽象就是看不懂的
  • B:抽象類特點
    • a:抽象類和抽象方法必須用abstract關鍵字修飾
      • abstract class 類名 {}
      • public abstract void eat();//當不知道該方法具體是怎麼實現的
        //比如動物吃，你知道它吃什麼嗎？怎麼吃？都不知道
    • b:抽象類不一定有抽象方法，有抽象方法的類一定是抽象類或者是接口
    • c:抽象類不能實例化那麼，抽象類如何實例化呢?
      • 按照多態的方式，由具體的子類實例化。其實這也是多態的一種，抽象類多態。
    • d:抽象類的子類
      • 要麼是抽象類
      • 要麼重寫抽象類中的所有抽象方法
  • C:案例演示
    • 抽象類特點
      案例：
class Demo1_Abstract {
	public static void main(String[] args) {
		//Animal a = new Animal();			//錯誤: Animal是抽象的; 無法實例化
		Animal a = new Cat();				//父類引用指向子類對象
		a.eat();
	}
}
abstract class Animal {						//抽象類
	public abstract void eat();				//抽象方法

	public Animal() {
		System.out.println("父類空參構造");
	}
}

class Cat extends Animal {
	public Cat() {
		super();
	}
	public void eat() {
		System.out.println("貓吃魚");
	}
}

09.10_面向對象(抽象類的成員特點)

  • A:抽象類的成員特點
    • a:成員變量：既可以是變量，也可以是常量。abstract是否可以修飾成員變量?不能修飾成員變量
    • b:構造方法：有。
      • 用於子類訪問父類數據的初始化。
    • c:成員方法：既可以是抽象的，也可以是非抽象的。
  • B:案例演示
    • 抽象類的成員特點
  • C:抽象類的成員方法特性：
    • a:抽象方法 強制要求子類做的事情。
    • b:非抽象方法 子類繼承的事情，提高代碼複用性。
      案例：
class Demo2_Abstract {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}
abstract class Demo {
	int num1 = 10;//變量
	final int num2 = 20;//常量

	public Demo(){}//構造方法

	public void print() {//非抽象方法，子類可以直接使用
		System.out.println("111");
	}

	public abstract void method();//抽象方法，子類必須實現
}

class Test extends Demo {
	public void method() {
		System.out.println("111");
	}
}

09.11_面向對象(葵花寶典)

  • 案例演示
    • 抽象類的作用
class Demo3_葵花寶典 {
	public static void main(String[] args) {
		嶽不羣 小嶽子 = new 嶽不羣();
		小嶽子.自宮();
	}
}

abstract class 葵花寶典 {
	public abstract void 自宮();
}

class 嶽不羣 extends 葵花寶典 {
	public void 自宮() {
		System.out.println("用牙籤");
	}
}

class 林平之 extends 葵花寶典 {
	public void 自宮() {
		System.out.println("用指甲刀");
	}
}

class 東方不敗 extends 葵花寶典 {
	public void 自宮() {
		System.out.println("用錘子,不忍直視");
	}
}

09.12_面向對象(抽象類練習貓狗案例)

  • A:案例演示
    • 具體事物：貓，狗
    • 共性：姓名，年齡，吃飯
    • 貓的特性:抓老鼠
    • 狗的特性:看家
      案例：
class Test1_Animal {
	public static void main(String[] args) {
		Cat c = new Cat("加菲",8);
		System.out.println(c.getName() + "..." + c.getAge());
		c.eat();
		c.catchMouse();

		Dog d = new Dog("八公",30);
		System.out.println(d.getName() + "..." + d.getAge());
		d.eat();
		d.lookHome();
	}
}
abstract class Animal {
	private String name;				//姓名
	private int age;					//年齡

	public Animal(){}					//空參

	public Animal(String name,int age) {//有參
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//設置姓名
		this.name = name;
	}

	public String getName() {			//獲取姓名
		return name;
	}

	public void setAge(int age) {		//設置年齡
		this.age = age;
	}

	public int getAge() {				//獲取年齡
		return age;
	}

	public abstract void eat();			//吃飯
}

class Cat extends Animal {
	public Cat(){}					//空參

	public Cat(String name,int age) {//有參
		super(name,age);
	}

	public void eat() {
		System.out.println("貓吃魚");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public Dog(){}					//空參

	public Dog(String name,int age) {//有參
		super(name,age);
	}

	public void eat() {
		System.out.println("狗吃肉");
	}

	public void lookHome() {
		System.out.println("看家");
	}
}

09.13_面向對象(抽象類練習老師案例)

  • A:案例演示
    • 具體事物：基礎班老師，就業班老師
    • 共性：姓名，年齡，講課。
    • 具體事物:基礎班學生,就業班學生
    • 共性:姓名,年齡,學習
      案例：
class Test2_Teacher {
	public static void main(String[] args) {
		BaseTeacher bt = new BaseTeacher("馮佳",18);
		bt.teach();
	}
}
abstract class Teacher {
	private String name;				//姓名
	private int age;					//年齡

	public Teacher(){}					//空參

	public Teacher(String name,int age) {//有參
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//設置姓名
		this.name = name;
	}

	public String getName() {			//獲取姓名
		return name;
	}

	public void setAge(int age) {		//設置年齡
		this.age = age;
	}

	public int getAge() {				//獲取年齡
		return age;
	}

	public abstract void teach();
}

class BaseTeacher extends Teacher {
	public BaseTeacher(){}					//空參

	public BaseTeacher(String name,int age) {//有參
		super(name,age);
	}

	public void teach() {
		System.out.println("我的姓名是:" + this.getName() + ",我的年齡是:" + this.getAge() + ",講的內容是java基礎");
	}
}

09.14_面向對象(抽象類練習員工案例)

  • A:案例演示
    • 假如我們在開發一個系統時需要對程序員類進行設計，程序員包含3個屬性：姓名、工號以及工資。
    • 經理，除了含有程序員的屬性外，另爲還有一個獎金屬性。
    • 請使用繼承的思想設計出程序員類和經理類。要求類中提供必要的方法進行屬性訪問。
      案例：
class Test3_Employee {
	public static void main(String[] args) {
		Coder c = new Coder("德瑪西亞","007",8000);
		c.work();

		Manager m = new Manager("蒼老師","9527",3000,20000);
		m.work();
	}
}
abstract class Employee {
	private String name;					//姓名
	private String id;						//工號
	private double salary;					//工資

	public Employee() {}					//空參構造

	public Employee(String name,String id,double salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}

	public void setName(String name) {		//設置姓名
		this.name = name;
	}

	public String getName() {				//獲取姓名
		return name;
	}

	public void setId(String id) {			//設置id
		this.id = id;
	}

	public String getId() {					//獲取id
		return id;
	}

	public void setSalary(double salary) {	//設置工資
		this.salary = salary;
	}

	public double getSalary() {				//獲取工資
		return salary;
	}

	public abstract void work();
}

//程序員
class Coder extends Employee {
	public Coder() {}					//空參構造

	public Coder(String name,String id,double salary) {
		super(name,id,salary);
	}

	public void work() {
		System.out.println("我的姓名是:" + this.getName() + ",我的工號是:" + this.getId() + ",我的工資是:" 
			+ this.getSalary() + ",我的工作內容是敲代碼");
	}
}

//項目經理
class Manager extends Employee {
	private int bonus;					//獎金
	public Manager() {}					//空參構造

	public Manager(String name,String id,double salary,int bonus) {
		super(name,id,salary);
		this.bonus = bonus;
	}

	public void work() {
		System.out.println("我的姓名是:" + this.getName() + ",我的工號是:" + this.getId() + ",我的工資是:" 
			+ this.getSalary() + ",我的獎金是:" + bonus + ",我的工作內容是管理");
	}
}

09.15_面向對象

  • A:試題1
    • 一個抽象類如果沒有抽象方法，可不可以定義爲抽象類?如果可以，有什麼意義?
    • 可以
    • 這麼做目的只有一個,就是不讓其他類創建本類對象,交給子類完成
  • B:試題2
    • abstract不能和哪些關鍵字共存
      案例：
class Demo4_Abstract {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

09.16_面向對象(接口的概述及其特點)

  • A:接口概述
    • 從狹義的角度講就是指java中的interface
    • 從廣義的角度講對外提供規則的都是接口
  • B:接口特點
    • a:接口用關鍵字interface表示
      • interface 接口名 {}
    • b:類實現接口用implements表示
      • class 類名 implements 接口名 {}
    • c:接口不能實例化
      • 那麼，接口如何實例化呢?
      • 按照多態的方式來實例化。
    • d:接口的子類
      • a:可以是抽象類。但是意義不大。
      • b:可以是具體類。要重寫接口中的所有抽象方法。(推薦方案)
  • C:案例演示
    • 接口特點
      案例：
class Demo1_Interface {
	public static void main(String[] args) {
		//Inter i = new Inter();		//接口不能被實例化,因爲調用抽象方法沒有意義
		Inter i = new Demo();			//父類引用指向子類對象
		i.print();
	}
}
interface Inter {
	public abstract void print();					//接口中的方法都是抽象的
}

class Demo implements Inter {
	public void print() {
		System.out.println("print");
	}
}

09.17_面向對象(接口的成員特點)

  • A:接口成員特點
    • 成員變量只能是常量，並且是靜態的並公共的。
      * 默認修飾符：public static final
      * 建議：自己手動給出。
    • 構造方法：接口沒有構造方法。
    • 成員方法：只能是抽象方法。
      * 默認修飾符：public abstract
      * 建議：自己手動給出。
  • B:案例演示
    • 接口成員特點
      案例：
class Demo2_Interface {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.print();
		System.out.println(Inter.num);
	}
}
interface Inter {
	public static final int num = 10;
	//public Inter(){}					接口中沒有構造方法

	/*public void print() {				接口中不能定義非抽象方法
	
	}*/

	public abstract void print();
}

class Demo /*extends Object*/ implements Inter {	//一個類不寫繼承任何類,默認繼承Object類
	public void print() {
		//num = 20;
		System.out.println(num);
	}

	public Demo() {
		super();
	}

}

09.18_面向對象(類與類,類與接口,接口與接口的關係)

  • A:類與類,類與接口,接口與接口的關係
    • a:類與類：
      • 繼承關係,只能單繼承,可以多層繼承。
    • b:類與接口：
      • 實現關係,可以單實現,也可以多實現。
      • 並且還可以在繼承一個類的同時實現多個接口。
    • c:接口與接口：
      • 繼承關係,可以單繼承,也可以多繼承。
  • B:案例演示
    • 類與類,類與接口,接口與接口的關係
      案例：
class Demo3_Interface {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}
interface InterA {
	public abstract void printA();
}

interface InterB {
	public abstract void printB();
}

interface InterC extends InterB,InterA {
}
//class Demo implements InterA,implements InterB {		//這麼做不允許是非法的
class Demo extends Object implements InterA,InterB {
	public void printA() {
		System.out.println("printA");
	}

	public void printB() {
		System.out.println("printB");
	}
}

09.19_面向對象(抽象類和接口的區別)

  • A:成員區別

    • 抽象類：
      • 成員變量：可以變量，也可以常量
      • 構造方法：有
      • 成員方法：可以抽象，也可以非抽象
    • 接口：
      • 成員變量：只可以常量
      • 成員方法：只可以抽象

  • B:關係區別

    • 類與類
      • 繼承，單繼承
    • 類與接口
      • 實現，單實現，多實現
    • 接口與接口
      • 繼承，單繼承，多繼承

  • C:理念區別

    • 抽象類 被繼承體現的是：”is a”的關係。抽象類中定義的是該繼承體系的共性功能。
    • 接口 被實現體現的是：”like a”的關係。接口中定義的是該繼承體系的擴展功能。
      • 對事物本質的抽象用抽象類，對事物功能的擴展用接口

09.20_面向對象(貓狗案例加入跳高功能分析及其代碼實現)

  • A:案例演示
    • 動物類：姓名，年齡，吃飯，睡覺。
    • 貓和狗
    • 動物培訓接口：跳高
      案例：
class Test1_Animal {
	public static void main(String[] args) {
		Cat c = new Cat("加菲",8);
		c.eat();
		c.sleep();

		JumpCat jc = new JumpCat("跳高貓",3);
		jc.eat();
		jc.sleep();
		jc.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 void setName(String name) {	//設置姓名
		this.name = name;
	}

	public String getName() {			//獲取姓名
		return name;
	}

	public void setAge(int age) {		//設置年齡
		this.age = age;
	}

	public int getAge() {				//獲取年齡
		return age;
	}

	public abstract void eat();			//吃飯

	public abstract void sleep();		//睡覺
}

interface Jumping {						//跳高的接口
	public void jump();
}

class Cat extends Animal {
	public Cat() {}					//空參構造

	public Cat(String name,int age) {//有參構造
		super(name,age);
	}

	public void eat() {
		System.out.println("貓吃魚");
	}

	public void sleep() {
		System.out.println("側着睡");
	}
}

class JumpCat extends Cat implements Jumping {
	public JumpCat() {}					//空參構造

	public JumpCat(String name,int age) {//有參構造
		super(name,age);
	}

	public void jump() {
		System.out.println("貓跳高");
	}
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Android 默認的設備存儲路徑獲取方法

boolean b1=Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); boolean b2=Environment.isExternalS

yeziyfx 2020-07-08 07:02:00

Android 沉侵式標題欄toolbar

1.開發環境：Android stuido4.0 Java1.8 2.測試設備：紅米Note 4x,Oppo k1,Oppo R11（測試正常，標題欄不佔用狀態欄，狀態欄可以正常設置爲亮色和神色） 3.佈局文件：toolbar_l

风正吹 2020-07-08 02:47:12

Android studio編輯器Could not find main class com/intellij/idea/Main

Android studio編輯器Could not find main class com/intellij/idea/Main Android studio第一次使用時安裝後打不來，出現could not find main

Robin_yy 2020-07-07 21:55:54

Android中View和ViewGroup的measure和layout過程分析

轉自：http://blog.csdn.net/aigestudio/article/details/42989325 要在數量上統計中國菜的品種，在地域上毫無爭議地劃分菜系，在今天，是一件幾乎不可能完成的事……Cut…………抱歉

SpiritView 2020-07-07 20:05:17

爲android運用添加菜單及對按鈕設置監聽和提示進入和關閉當前活動的Activity

添加菜單的方法有很多，一般推薦用xml創建菜單。 建立menu步驟： 在res下建立一個menu文件夾，在menu文件裏面添加一個xml文件： [html] <?xml version="1.0" encoding="utf-8"

流年跌碎容颜 2020-07-07 19:59:15

android開發中的cursor

 1.關於 Cursor，在你理解和使用 Android Cursor 的時候你必須先知道關於 Cursor 的幾件事情： Cursor 是每行的集合。 使用 moveToFirst() 定位第一行。 你必須知道每一列的名稱。 你必須知道

流年跌碎容颜 2020-07-07 19:59:15

Android入門【0】-開篇語

       近期工作之餘，有興趣玩玩Android應用開發，我會將學習的內容，結合自己的組織、收集、整理，形成一個Android開發入門的系列文章，自我提升之餘，也希望能爲其他開發人員分享一些經驗

xiaoqing_lee 2020-07-06 21:17:23

【Android基礎知識】網絡獲取Xml文件並解析

從服務器獲取xml內容並解析 girls.xml <?xml version="1.0" encoding="utf-8"?> <girls> <girl> <name>tian</name> <age>12</age> <

BetterRamon 2020-07-06 20:32:27

【Android基礎知識】Apache HttpClient的基本使用

使用Apache HttpClient 使用get和post方式向服務器發送請求 請求代碼 public class HttpClientThread extends Thread { private String url; priv

BetterRamon 2020-07-06 20:32:27

【Android基礎知識】HttpUrlConnection使用doGet和doPost方式和服務器交互

這裏介紹HttpUrlConnection使用get方式或post方式和服務器進行數據交互 1.建立服務器端Web程序MyServlet 在doGet方法中調用doPost方法，在doPost方法中接收客戶端發送來的數據 public

BetterRamon 2020-07-06 20:32:27

【Android基礎知識】Android多線程下載

使用Android 多線程進行下載，需要使用網絡操作，線程池，文件操作的知識,這裏自己搭建一個服務器，創建一個web工程，webroot下面放置一張圖片就可以了。 多線程下載 Download.java public class Down

BetterRamon 2020-07-06 20:32:27

【Android基礎知識】網絡操作：Json生成與解析

簡介 這裏主要介紹Android生成一個Json格式的字符串，客戶端通過網絡獲取服務器端生成的Json字符串進行解析，根據解析出來的Url去網絡獲取圖片並顯示在ListView中。最終實現效果如下 Json字符串爲 { "res

BetterRamon 2020-07-06 20:32:27

Android基礎之動畫

Android動畫有兩種Tween（形變動畫）和Frame（幀動畫）,使用時可以在res\anim路徑下創建動畫的xml，也可以代碼實現。 Tween裏包含了： Scale：縮放動畫、Rotate：旋轉動畫、Translate

s1991721 2020-07-06 18:28:48

Android基礎之文件上傳

public class FileUploader extends Thread { /** * 超時時間 */ public static final int IWP_HTPPCIIENT_T

s1991721 2020-07-06 18:28:48

根據屏幕寬度，等比例縮放圖片

實現圖片適應屏幕寬度方式：獲取屏幕大小，動態設置控件高度。 ImageView有scaleType屬性可以縮放圖片，讓圖片鋪滿屏幕寬度，但是會出現壓縮或裁剪的情況。 ImageView的scaleType的屬性分別是matrix

曹俊飞 2020-07-05 10:24:03