字面量:
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);
}
}
腾讯云开发者
