Android入门教程(五)

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


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


字面量:
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;


23
抽象函数的语法特征
抽象类的语法特征
抽象类的作用

类是抽象的,对象是具体的
比类更抽象的,就是抽象类
先抽象,后具体


什么是抽象函数?
只有函数的定义,没有函数体的函数被称为抽象函数
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);
 }
}

从入门到熟悉!

坚决不放弃!


喜欢本文的朋友们

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

收看更多精彩内容



posted @ 2018-02-04 15:07  达达前端  阅读(104)  评论(0编辑  收藏  举报