Android学习笔记day9

fianl关键字：

1、final在JAVA中被称为完结器，表示最终的意思。

2、final能声明类、方法、属性。

使用final声明的类不能被继承。

使用final声明的方法不能被重写。

使用final声明变量变成常量，常量是不可以被修改的。

抽象类：

1、抽象类概念：包含一个抽象方法的类就是抽象类。

2、抽象方法;

声明而未被实现的方法，抽象方法必须使用abstract关键字声明。

3、抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中的所有抽象方法。

4、定义格式：

abstract class className{

属性

方法

抽象方法

}

5、抽象类不能直接实例化，必须通过子类进行实例化。

接口：

1、接口是JAVA中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。

2、接口的格式：

interface interfaceName{

全局常量

抽象方法

}

3、接口的实现也必须通过子类，使用关键字implements，而且接口是可以多实现的。

4、一个子类可以同时继承抽象类和实现接口。

5、一个接口不能继承一个抽象类，但是却可以通过extends关键字同时继承多个接口，实现接口的多继承。

多态：

1、多态性的体现：

方法的重载与重写。

对象的多态性。

2、对象的多态性：

向上转型：程序会自动完成。

父类 父类对象 = 子类实例

向下转型：强制类型转换

子类 子类对象 = （子类）父类实例

代码实例：

package digui.jikexueyuan.com;
class A{
public void tell1(){
System.out.println("A--tell1");
}
public void tell2(){
System.out.println("A--tell2");
}
}
class B extends A{
public void tell1(){
System.out.println("B--tell1");
}
public void tell3(){
System.out.println("B--tell2");
}
}
public class java01 {


public static void main(String[] args) {
//向上转型
// B b = new B();
// A a = b;
// a.tell1();
// a.tell2();
//向下转型
A a = new B();
B b = (B)a;
b.tell1();
b.tell2();
b.tell3();
}
}

instanceof关键字：

在JAVA中可以通过intanceof关键字判断一个对象到底是不是一个类的实例。

抽象类的应用：

代码实例：

package digui.jikexueyuan.com;
abstract class Person{
private int age;
private String name;
public Person(int age,String name){
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void want();
}
class Student extends Person{
private int score;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Student(int age, String name,int score) {
super(age, name);
this.score = score;
}
public void want() {
System.out.println("姓名："+getName()+" 年龄："+getName() +" 成绩："+getScore());
}
}
class Worker extends Person{
private int money;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public Worker(int age, String name,int money) {
super(age, name);
this.money = money;
}
public void want() {
System.out.println("姓名："+getName()+" 年龄："+getName() +" 工资："+getMoney());
}
}
public class zuoye09 {


public static void main(String[] args) {
Student s = new Student(10,"小明",100);
s.want();
Worker w = new Worker(39,"大明",8000);
w.want();
}
}

day5作业：

1、

get方法和set方法

定义一个类，该类有一个私有成员变量，通过构造方法将其进行赋初值，并提供该成员的getXXX()和setXXX()方法

提示：假设有private String name;则有

public void setName(String name){

this.name = name;

}

 

public String getName(){

return this.name;

}

答案：

package digui.jikexueyuan.com;


class Person{
private String name;
public Person(String n){
this.setName(n);
}
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void getInfo(){
System.out.println("名字："+name);
}
}


public class zuoye05 {


public static void main(String[] args) {
Person per = new Person("奥巴马");
per.getName();
per.getInfo();
}
}

2、

构造方法与重载

为“无名的粉”写一个类：class WuMingFen 要求：

1.有三个属性：面码:String theMa  粉的分量(两)：int quantity 

      是否带汤：boolean likeSoup

2.写一个构造方法，以便于简化初始化过程，如：

WuMingFen f1 = new WuMingFen("牛肉",3,true);

3.重载构造方法，使得初始化过程可以多样化：

WuMingFen f2 = new WuMingFen("牛肉",2);

4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的？

WuMingFen f3 = new WuMingFen();

5.写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上。

答案：

package digui.jikexueyuan.com;


class WuMingFen{
String theMa;
int quantity;
boolean likeSoup;
public WuMingFen(){

}
public WuMingFen(String theMa,int quantity){
this.theMa = theMa;
this.quantity = quantity;
}
public WuMingFen(String theMa,int quantity,boolean likeSoup){
this(theMa,quantity);
this.likeSoup = likeSoup;
}
public void check(){
System.out.println("面码："+theMa+"\n粉的分量"+quantity+"\n是否带汤："+likeSoup);
}
}


public class zuoye06 {


public static void main(String[] args) {
WuMingFen f1 = new WuMingFen("牛肉",3,true);
WuMingFen f2 = new WuMingFen("牛肉",2);
WuMingFen f3 = new WuMingFen();
f1.check();
f2.check();
f3.check();
}
}

3、构造方法与重载

将上次练习题三中编写的MyTime类打到以自己名字的拼音命名的包中，并为该类重载一组构造方法，以方便使用者能够以多种形式初始化该类的实例。

答案：

package digui.jikexueyuan.com;
class MyTime
{
private int hour;
private int minute;
private int second;
public MyTime(int hour,int minute,int second){
 this.hour = hour;
 this.minute = minute;
 this.second = second;
}
public MyTime(int minute,int second){
 this.minute = minute;
 this.second = second;
}
void diaplay(){
System.out.println("时间："+hour+":"+minute+":"+second
);
}
void addSecond(int sec){
 second = second+sec;
}
void addMinute(int min){
  minute = minute+min;
}
void addHour(int hou){
  hour = hour+hou;
}
void subSecond(int sec){
  second = second-sec;
}
void subMinute(int min){
  minute = minute-min;
}
void subHour(int hou){
  hour = hour-hou;
}
void Test(){
if(hour<=23&hour>=0&minute<=59&minute>=0&second<=59&second>=0)
System.out.println("\nTrue\n");
else
System.out.println("\nFalse\n");
}
}
public class zuoye07 {


public static void main(String[] args) {
 MyTime b = new MyTime(11,4,55);
//  b.addHour(1);
//  b.addMinute(5);
//  b.addSecond(2);
//  b.diaplay();
//  b.Test();
 b.subHour(5);
 b.subMinute(5);
 b.subSecond(2); 
 b.diaplay();
 b.Test();
}
}

4、

Static关键字与普通变量的区别：

创建一个名称为StaticDemo的类，并声明一个静态变量和一个普通变量。对变量分别赋予10和5的初始值。在main()方法中输出变量值。

答案：

package digui.jikexueyuan.com;
class StaticDemo{
private static int a = 10;
private int b = 5;
public String getInfo(){
return "a="+a+"\nb="+b;
}
}
public class zuoye08 {


public static void main(String[] args) {
StaticDemo m = new StaticDemo();
System.out.println(m.getInfo());
}
}

5、

类的成员变量与方法、构造方法

在程序中，经常要对时间进行操作，但是并没有时间类型的数据。那么，我们可以自己实现一个时间类，来满足程序中的需要。

定义名为MyTime的类，其中应有三个整型成员：时（hour），分（minute），秒（second），为了保证数据的安全性，这三个成员变量应声明为私有。

为MyTime类定义构造方法，以方便创建对象时初始化成员变量。

再定义diaplay方法，用于将时间信息打印出来。

 答案：