Android入门教程（五）-蒲公英云

关注我，每天都有优质技术文章推送，工作，学习累了的时候放松一下自己。

欢迎大家关注我的微信公众号：「醉翁猫咪」

SouthEast

字面量:

1.整数字面量为整型(int)

2.小数字面量为双精度浮点型(double)

0.5*10结果为双精度浮点型

byte short int long float double

public class TestSwitch{
public static void main(String args []){
char c = 'a';
switch(c){
case 'b':
System.out.println('b');
break;
case 'c':
System.out.println('c');
break;
case 'a':
System.out.println('a');
break;
default:
System.out.println('d');
}
    }
}

switch( char byte short int )只允许四种类型

public class Test01{
 public static void main(String args []){
 int score = 90;
 if(score > 85 && score <= 100){
 System.out.println("成绩为优");
 }
 else if(score > 75 $$ score <= 85){
 System.out.println("成绩为良");
 }
 else if(score > 60 $$ score <= 75){
 System.out.println("成绩为中");
 }
 else if(score <= 60 && score >= 0){
 System.out.println("成绩为差");
 }
 else if(score > 100 || score < 0){
 System.out.println("成绩不在正常的范围之内");
 }
 }
}

for(int i = 0; i < 10; i++){

System.out.println(i);

}

public class TestWhile{
 public static void main(String args []){
  int i = 0;
  while(i < 10){
   System.out.println(i);
   i++;
   } 
  }
}

打印出100-200之间的所有素数

一个数字只有一和它自己被整除

定义一个类，名为TestPrimeNumber

在类当中定义主函数

用for循环打印出所有在100-200之间的数字

在for循环当中，每当循环执行一次，就判断循环变量是否为素数，如果是，就将循环变量的当前值打印出来；

判断n是否为素数，首先用2除n，如果除不尽，再用3除n，依次类推，如果从2到n-1都无法整除n，那么n就是素数。

class TestPfrimeNumber{
 public static void main(String args []){
  for(int i = 100; i < 201; i++){
   boolean b = false;
   for(int j = 2 ; j < i - 1; j++){
    int k = i % j;
     if(k == 0){
      b = true;
     }
    }
//如果不是true就打印出素数
    if(!b){
     System.out.println(i);
    }
   }
  }
}

打印图形

public class Test{
public static void main(String args[]){
int i = 5;
int j = i++ + 5;
System.out.println(j);
System.out.println(i);
}
}

j=10;

i=6;

int j = ++i + 5;

System.out.println(j);

j=11;

i=6;

& 逻辑与

&& 短路与

class TestTriangle{
public static void main(String args []){
 for(int i=1; i<5; i++){
  for(int j=0; j<4-i; j++){
   System.out.print(" ");
  } 
  for(int k=0; k<i; k++){
   System.out.print("* ");
  }
  System.out.println("");
  }
 }
}

什么是面向对象？

面向对象是一种编程方法

面向对象是一种思维方式

面向对象不是一种编程语言

应该如何学习面向对象？

掌握一门面向对象语言的语法

掌握面向对象的思维方式

熟悉面向对象设计原则

掌握面向对象设计模式

什么是面向对象思维方法？

1.首先确定谁来做，其次确定怎么做

2.首先考虑整体，其次考虑局部

3.首先考虑抽象，其次考虑具体

不要认为掌握了一门面向对象语言就是掌握了面向对象

习惯了将面向对象与现实世界做比较

14

创建类的方法

创建对象的方法

对象和对象的引用

定义类的方法

class类名

{

属性；

方法；

}

属性也叫成员变量，主要用于描述类的状态

方法也叫成员方法，主要用于描述类的行为

age是类的属性，也叫类成员变量

shout是方法也叫类的成员函数

shout方法可以直接访问用一个类中的age变量,如果一个方法中有与成员变量同名的局部变量，该方法中对这个变量名的访问是局部变量，而不再是成员变量

生成对象的方法

格式：类名对象名=new类名（）

例如：Dog dog = new Dog();

创建一个Dog的引用

创建一个Dog的对象

类和对象的关系

类是抽象，而对象是具体的。

变量的类型变量的值

Java的数据类型基本数据类型和引用数据类型

对象就是引用数据类型

生成对象的方法

Java虚拟机把内存分为栈内存和堆内存

对象就叫引用数据类型

应该如何学习面向对象

面向对象的思维方式

class Test{
public static void main(String args []){
Dog d = new Dog();
d.name="旺财";
d.age=2;
d.color="黑色";
d.jump();
System.out.println("名字是"+d.name);
}}

对象的使用方法，多对象的创建方法，匿名对象的创建和使用方法。

对象的使用方法

使用对象调用变量和函数

对象.变量

对象.函数（）

生成多个对象

匿名对象的使用

可以不定义对象的引用名称，而直接调用这个对象的方法，这样的对象叫做匿名对象。

如：new Dog（）.jump（）;

函数的重载和构造函数的作用

重载的表达

class A{
 void funA(){
  System.out.println("没有参数的funA函数");
 }
 void funA(int i){
  System.out.println("拥有一个整型参数的funA函数");
 }
 void funA(int i,double d){
  System.out.println("拥有两个参数的funA函数");
}
class Test{
 public static void main(String args[]){
  A a = new A();
  a.funA();
  a.funA(1,3.2）；
  }
}

什么叫函数的重载呢？

1.两个或者多个函数在同一个类当中；

2.函数名相同；

3.参数列表不同

什么是构造函数？

A（）{

}

使用this调用成员变量和成员函数

使用this调用构造函数

1.静态成员变量只有一份

2.在静态函数当中不能使用this;

3.静态代码块的主要作用是为静态成员变量赋值。

class Person{
 static{
  System.out.println("dd");
 }
 static String name;
 ..
}

继承，封装，多态

什么是继承？

为什么要使用继承，

继承特点

什么是继承？

在现实世界当中，继承就是儿子得到了老子的东西；

在面向对象的世界当中，继承就是一个类得到了另一个类当中的成员变量和成员方法；

Java当中只支持单继承

Java只支持单继承，不允许多继承。

总结：

使用继承是为了减少重复代码

继承的基本语法

子类实例过程

生成子类的过程

使用super调用父类构造函数的方法

class Person{
 String name;
 int age;
 Person(){
  System.out.println("Person的无参数构造函数");
 }
 Person(String name,int age){
  this.name = name;
  this.age = age;
  System.out.println("Person有参数构造函数");
 }
 void eat(){
  System.out.println("吃饭");
 }
}
class Student extends Person{
//在子类的构造函数当中，必须调用父类的构造函数
 Student(){
  super();
  System.out.println("Student的无参数构造函数");
 }
 Student(String name,int age,int a){
  super(name,age);
  this.a = a;
}

继承只能继承成员变量成员函数

class Test{
 public static void main(String args[]){
  Student student = new student();
 }
}

虽然子类不能继承父类的构造函数，但我能用super（）来调用父类的构造函数。调用子类的构造函数，一定会调用父类的构造的函数。

听懂了实例过程

函数的复写（override）

使用super调用父类的成员函数

//复写（override）也被称之为覆盖或者重写

//在具有父子关系的两个类当中

//父类和子类各有一个函数，这两个函数的定义（返回值类型，函数名和参数列表）完全相同

class Student extends Person{
 String address;
 void introduce(){
  super.introduce();
  System.out.println("我的家在"+address);
 }
}

对象的转型（多态性的体现）

对象的向上转型和向下转型

什么是向上转型？

向上转型就是将子类的对象赋值给父类的引用。

Student s = new Student();

Person p = s;

//一个引用能够调用哪些成员（变量和函数），取决于这个引用类型

//一个引用调用的是哪一个方法，取决于这个引用所指向的对象。

class Test{
 public static void main(String args[]){
  String s = new Student();
  Person p = s;
  p.name = "hhh";
  p.age = 20;
  //p.address = "beijing";
  p.introduce();
  //p.study();
  }
}

什么是向下转型？

向下转型就是将父类的对象赋值给子类的引用

Student s1 = new Student();

Person p = s1;

Student s2 = (Student)p;

抽象函数的语法特征

抽象类的语法特征抽象类的作用

类是抽象的，对象是具体的

比类更抽象的，就是抽象类

先抽象，后具体

什么是抽象函数？

只有函数的定义，没有函数体的函数被称为抽象函数

abstract void fun();
class Person{
 String name;
 int age;
 void introduce(){
  System.out.println("我的名字是"+name+",我的年龄是"+age);
  }
  abstract void eat();
}

什么是抽象类？

使用abstract定义的类被称之为抽象类

抽象类不能够生成对象；

如果一个类当中包含有抽象函数，那么这个类必须被声明为抽象类

如果一个类当中没有抽象函数，那么这个类也可以被声明为抽象类

抽象类不能实例化

继承抽象类，那么该类必须为抽象类

复写，可以使用复写，就可以使用抽象类

class Chinese extends Person{

void eat(){

System.out.println(“hhh”);

}

class Test{

public static void mian(String args[]){

Person p = new Chinese();

p.eat();

}

抽象类为基类，其他的类来继承它，就是当爹的

抽象类可以有构造函数吗？

条件：

抽象类不能生成对象

构造函数用于生成类的对象

super的作用

abstract class Person{
 Person(){
  System.out.println("Person的构造函数");
 }
 Person(String name,String age){
  this.name = name;
  this.age = age;
} 
 String name;
 int age;
 void introduce(){
  System.out.println("我的名字是"+name+",我的年龄是"+age);
 }
 abstract void eat();
}
class Chinese extends Person{
 String address;
 Chinese(){
  super();
  System.out.println("Chinese的构造函数");
 }
 Chinese(String name,int age,String address){
  super(name,age);
  this.address = address;
}
 void eat(){
  System.out.println("用筷子吃饭");
 }
}
class Test{
 public static void main(String args[]){
  Person p = new Chinese();
  P.eat();
  }
}

不能调用抽象类的构造函数，但可以用子类来调用抽象函数，生成子类对象的时候使用调用构造函数。

结论：

抽象函数就是没有函数体的函数

抽象类使用abstract来定义

抽象类不能生成对象，但是却可以拥有构造函数，这个构造函数是为了子类准备的。

24为什么用抽象类。

如果一段代码在语意上是有错误的，那么在语法上也应该是有错误的

abstract class Printer{
 void open(){
  System.out.println("open");
 }
 void close(){
  System.out.println("close");
 }
 abstract void print();
}

25什么是Java当中的软件包？

为什么要用软件包？

如何给一个类打包？

//将类放置到一个包当中，需要使用package“包名”

//编译时需要使用-d参数,该参数的作用是依照包名生成相应的文件夹

//一个类的全名应该是“包名”+”.”+”类名”

//hhh.Test,执行的话，要使用java hhh.Test

//包名的命名规范

//要求包名所有的字母都要小写

//包名一般情况下，是你的域名倒过来写

package hhh;
class Test{
 public static void main(String args[]){
  System.out.println("hellos");
 }
}

软件包为Java类提供了命名空间

打包需要使用package指令

一个类的全名应该是“包名”+“类名”

包和访问权限的语法

Java当中的访问权限

public : 公共权限

private : 私有权限

default:包级别访问权限

protected:受保护权限

27包和访问权限

访问权限与继承的关系

protected权限

//如果子类和父类不在同一包当中，则子类无法继承到父类当中的default权限的成员变量和成员函数(有问题）

//如果子类和父类不在同一包当中，子类可以继承到父类当中的default权限的成员变量和成员函数，但是由于权限不够，无法使用

protected 权限首先拥有和default一样的功能，但是该权限只能修饰成员变量和成员函数

//public > protected > default > private

package com.hh;
public class Person{
 String name;
 int age;
 void eat(){
  System.out.println("eat");
 }
 void sleep(){
  System.out.println("sleep");
 }
}
package cn.mm;
import com.hh;
class Student extends Person{
 void introduce(){
  System.out.println("我的名字是"+name+",haha"+age);
 }
}