Android入门教程（五）

小咪咪 2021-09-14 16:30 373阅读 0赞

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

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

![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);
     }
    }

从入门到熟悉！

坚决不放弃！

![2_02.png_wx_lazy_1][]

喜欢本文的朋友们

欢迎长按下图关注订阅号醉翁猫咪

收看更多精彩内容

![SouthEast 1][]

[SouthEast]: /images/20210724/bf5f4c77c0054896bfc9258583c55352.png
[2_02.png_wx_lazy_1]: /images/20210724/5e3aaed5f81441f39cd370ea173ca96e.png
[SouthEast 1]: /images/20210724/09a3234751c4493d8daedb081b59ae4a.png