JAVA笔记

第一章进制数
JAVA用的是十进制，但底层用的是二进制。

十六进制：
十六进制一位数代表二进制四位数。

关系运算：
关系运算比算数运算优先级低，但比赋值运算高。

判断是否相等==和！=优先级低
6>5>4这句话是错的，6>5是true而true和数字是不能比较大小。

两个浮点数不能直接比较，浮点数做运算时存在误差，
Class 后面的类名和文件名完全一样，main方法是JAVA程序执行的入口点，所有单词不变，String中的S必须要大写，程序输出小括号中的内容可以变其他单词不变。

变量与数据类型
任何数据都可以用字符串（string）储存
变量的使用
Public class t1{
Public static void main (string args[]){
Int s ; //声明
S=10000; //赋值
System.out.println(s)；
}
}
字符串必须写在双引号里面，字符写在单引号里面。

String y=”张三”; char b =’男’ ;
System.out.println(“姓名：”+y); //字符串和变量用+连接变量的命名规则和常见错误
驼峰命名法：混合使用大小写int myAge;
匈牙利命名：开头字母用变量类型缩写int iMyAge;
大驼峰法：开头字母用大写
运算符
%取余
=为赋值运算符
== 为关系运算符关系运算符比较的结果：boolean类型逻辑运算符三目运算：布尔类型表达式？值1：值2 Int i = 10>5 ?1:2 ; 先判断布尔表达式真取值1 假取值2
Scanner input = new scanner(system .in);
Int vip = intput.nextInt ();
基础语法
循环结构
For 语句
Double d = Math.random ()*10;
System.out.println ((int)d) // 强制类型转换
等同于int d =（int）(Math.random ()*10);
多重循环使用if ,else if,if
Switch 语句
通过表达式成立与否选择执行哪条语句。

Switch ()
{
Case 表达式1：
{
结果与1匹配时执行的语句；
Break;
}
Case 表达式2：
{
结果与2匹配时执行的语句；
Break;
}
.....
Defualt:
表达式与以上都不匹配时执行的语句；
}
常见错误：break 必须要有，default 通常在程序末尾publicclass Test2 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
int i=1;
int gang=0;
while(i<100) {
if(i%2==1) {
gang=gang+i;
}
i++;
}
System.out.println("奇数和："+gang);
}
}
循环结构：
While
import java.util.Scanner;
publicclass Test2 {
main(String[] args) {
new Scanner(System.in);
String answer = "no";
while (answer.equals("no")) // 字符的比较
{
System.out.println("上午看书下午编程");
System.out.println("老师我合格了吗");
answer = input.next(); //输入字符不用input.nextInt }
}
}
FOR循环
For (参数初始化；条件判断；更新循环变量){
循环操作；
}
先初始化，再进行参数判断，再执行循环体，执行完循环体后再更新参数变量。

publicclass For {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
System.out.print("输入学生姓名："); // 如果是println 则输入会换行
Scanner input = new Scanner (System.in);
String name = input.next();
int gang = 0;
for(int i =1;i<=5;i++) {
System.out.println("请输入第"+i+"门");
int fen = input.nextInt();
gang = gang+fen;
}
System.out.println("平均分："+gang/5);
}
}
Continue
publicclass For {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
int sum = 0 ;
int i ;
for (i = 0;i<=10;i++) {
if (i==5) {
continue;
}
System.out.println(i);
}
终止本次循环直接执行下一次循环。

结果：0,1,2,3,4,6,7,8,9,10
第四章数组
1，声明数组
Int [] score1; int score2[], string []name
2, 分配空间
告诉计算机分配几个连续地空间
Score = new int [10]
3, 赋值
Score [0] = 1
边声明边赋值
Int [] score = new int [] {1,2,3};
import java.util.Scanner;
publicclass For {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner (System.in );
int Arrey[] = newint [] {8,4,2,1,23,34,12};
int sum = 0 ; // 数组长度用arrlength表示
for (int i =0; i<Arrey.length ; i++) {
System.out.print(Arrey[i]+""); // 同行，用空格间隔sum = sum + Arrey[i];
}
System.out.println("和："+sum);
System.out.println("请输入一个数：");
int num = input.nextInt();
for (int i = 0;i<=Arrey.length;i++) {
if ( num==Arrey[i] ) {
break;
}
}
System.out.println(num);
}
}
8 4 2 1 23 34 12 和：84
请输入一个数：1
1
数组的应用
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
Scanner (System.in);
System."请输入五个同学成绩："+"");
int fen[] = newint[5];
for (int i= 0;i<fen.length;i++) {
fen[i] = input.nextInt();
}
System.out.println("排序前：");
for (int i =0 ;i<fen.length;i++)
{
System.out.print(fen[i]+"");
}
System.out.println("排序后：");
Arrays.sort(fen); // 数组的排序
for (int i =0 ;i<fen.length;i++)
{
System.out.print(fen[i]+"");
}
}
}
输出最后一个数组：Arr[Arr.length-1]
冒泡法排序
Int jilu = arr[0];
For (int i = 0;i<arr.length ;i++){
If（arr[i]>jilu）{
Jilu=arr[i];
}
}
任何数字和double类型做运算得出的都是double类型
循环嵌套
publicclass Test11 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
for (int i=1;i<=5;i++) {
for (int j =1;j<=i;j++) {
System.out.print("*"); //*不换行
}
System.out.println();
}
}
}
输出等腰三角形
两个相对的三角形，将一个三角形插入到另一个中，把其中一个换成空格即可publicclass Test11 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
for (int i=0;i<=5;i++) {
for (int j=5;j>=i;j--) {
System.out.print("");
}
for (int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println("");
}
}
}
输出乘法表
publicclass Test11 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
for (int i =1;i<=9;i++) {
for (int j=1;j<=i;j++) {
int sum=0;
sum=i*j;
System.out.print(i+"*"+j+"="+sum+"");
}
System.out.println("");
}
}
}
第五章类和对象
类和对象
对象：描述实物的一个实体
方法：对象执行的操作
从对象中抽取的类别即类，类是抽象的概念，对象是一个看的到摸的到的具体实体。

人类即类，爸爸即一个对象。

定义一个简单的类:
Class Vehicle{
Int passengers;
Int mpg;
}
再创建对象：
Vehicle v=new Vehicle();
这条语句包含了四个动作：
1，右边的new Vehicle，是以类为模板在堆空间里创建一个对象
2，末尾的（）表示在对象创建之后立即调用Vehicle类的构造函数对生成的对象初始化，构造函数肯定存在，如果没有写，则JAVA会有一个默认的构造函数
3，左边是创建了Vehicle 类引用变量，所谓vehicle类引用就是以后可以用来指向vehicle 对象的对象引用。

4， = 操作符使对象引用指向刚刚创建的对象
可以将这条语句拆分为下面：
Vehicle v ;
V = new vehicle();
一个类里面可以创建很多对象，如果对象连名字都没有，那我们就不能访问他们，我们只能通过对象引用间接地访问对象。

只有Vehicle v ; 时即只有引用，并没有指向对象，会被系统赋予默认值null。

对象相当于一个气球，引用变量相当于一根绳子，有了绳子我们才能轻易的抓住那个气球。

一个对象引用可以指向0或1个对象，一个对象可以由N个引用指向他。

String s;
s= new String("java");
String s1 = s;
s1.append ("world");
System.out.println(s.toString());
System.out.println(s.toString());
两个打印出来的结果是一样的，s和s1仅仅是两个引用，现在两个引用指向的是一个对象，通过他们得到的也是一个对象的内容。

public class teacher{
// 属性
String name ;
String teach;
String teachage;
//方法
Public void teachstyle;
}
publicclass Student {
String name;
String teach;
int teachage;
publicvoid teachstyle(){
System.out.println("大家好");
System.out.println("教授方向："+teach);
}
}
publicclass S1 {
publicstaticvoid main(String[] args) {
//根据老师类创建一个对象wo
Student wo = new Student();
= "sun";
wo.teach = "java";
wo.teachage = 5;
wo.teachstyle();
}
}
大家好
教授方向：java
package text2;
import java.util.Scanner;
publicclass Youren {
String name;
int age;
publicvoid buy() {
for (;;) { //死循环
Scanner input = new Scanner (System.in);
System.out.print("name:");
name=input.next();
if (name.equals("n")) {
break;
} //s输出为n则结束循环
System.out.print("age:");
age=input.nextInt();
if (age>=18) {
System.out.println(name+"的年龄"+age+"门票为20");
}else {
System.out.println(name+"的年龄"+age+"门票为免费");
}
}
}
}
package text2;
publicclass t2 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
Youren u=new Youren();
u.buy();
}
}
在进行面向对象编程的时候，方法和成员变量都写在具体的对象里，并对其方法和成员变量都具有很好的隐藏性，对象之间的访问都是通过接口进行的。

抽象是指在定义类的时候，确定该类的行为和动作，比如自行车可以移动，但怎么移动不进行说明。

Bike b = new Bike ();
New一个对象，该对象在内存中是存在的，用b表示对这个bike类对象的引用，使用b就能使用这个对象的数据。

BIKE是类,b是引用，new bike （）是对象。

使用类时可以使用JAVA中现有的类，String s = new String ();
Java中自带String类，描述的是一个字符串。

局部变量是在方法体内创建的，能被final修饰，但不能被
public ,protected,default,private,static,修饰
成员变量在堆内创建，局部变量在栈内创建。

在参数为基本类型进行传递的时候，是传递的这个值的备份，无论方法中怎么改变这个备份，都不是操作原来的数，所以原来的值是不会改变的。

用new关键字创建的对象地址是重新分配的，equals方法比较的是对象的引用，是Object 类的方法。

方法的返回值
如果方法具有返回值，方法中必须使用关键字return返回该值，返回值的类型为该返回值的类型 return 表达式；作用：跳出方法返回结果
如果方法没有返回值，则返回值类型为void
方法之间允许互相调用，不需要知道方法的具体实现，实现重用提高效率
publicclass Ceshi {
publicvoid a () {
}
publicvoid b () {
a(); // 在b中调用a
}
}
不同类之间的调用需要new一个对象，同一类之间可以直接进行调用
方法之间不能相互钱傲定义
不能在方法外部写逻辑代码，逻辑代码只能写到方法里面
publicclass Ceshi {
int java ;
int c;
int DB;
publicint zong () {
return java+c+DB ;
}
}
publicclass t2 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
Ceshi t= new Ceshi();
Scanner input = new Scanner(System.in);
t.c=input.nextInt();
t.DB=input.nextInt();
t.java=input.nextInt();
System.out.println("zong:"+t.zong());
}
}
输出总成绩
成员变量和局部变量
变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域
JAVA会给成员变量一个初始值，但不会给局部变量初始值
不同的方法可以定义同样的变量
封装
人机猜拳
分析业务，抽象出类和类的行为和特征，创建用户类
Person.java
package caiquan;
import java.util.Scanner;
publicclass Person {
String name;
int fen;
Scanner input = new Scanner(System.in);
publicvoid setName() { //设置姓名
System.out.println("请输入你的姓名：");
name= input.next();
}
publicint chu() {
System.out.println("请出拳：1，石头，2.剪刀3.布");
int choose ;
choose = input.nextInt();
switch (choose) {
case 1:
System.out.println("你出拳为石头");
break;
case 2:
System.out.println("你出拳为剪刀");
break;
case 3:
System.out.println("你出拳为布");
break;
}
return choose;
}
}
Computer.java
package caiquan;
import java.util.Scanner;
publicclass Computer {
String name ;
int fen ;
Scanner input = new Scanner(System.in);
publicint setName() {
System.out.println("请选择角色：1，张三2，李四3，王五");
int choose;
choose = input.nextInt();
switch (choose) {
case 1:
name="张三";
break;
case 2:
name = "李四" ;
break;
case 3:
name = "王五";
break;
}
return choose;
}
publicint chu () {
int choose = (int)(Math.random()*3);
switch (choose){
case 0:
System.out.println(name+"出拳为石头");
break;
case 1:
System.out.println(name+"出拳为剪刀");
break;
case 2:
System.out.println(name+"出拳为布");
break;
}
return choose+1;
}
}
Game.java
package caiquan;
import java.util.Scanner;
publicclass Game {
Scanner input =new Scanner (System.in);
publicvoid start() {
Person p=new Person();
Computer c = new Computer();
System.out.println("\t*********************");
System.out.println("\t***猜拳开始***");
System.out.println("\t*********************");
System.out.println("出拳规则：1，石头 2，剪刀 3，布");
c.setName();
p.setName();
System.out.println(+ "vs"+);
//没有固定的循环次数，使用while ，对y ,n 不用做其他处理
System.out.println("是否要开始吗？");
String answer= input.next();
int ci=0;
while(answer.equals("y")) {
ci++;
int pquan=p.chu();
int cquan=c.chu();
if((pquan==1&&cquan==2)||(pquan==2&&cquan==3)||(pquan==3&&cquan==1)) {
System.out.println( +"win");
p.fen ++;
}else {
if((pquan==1&&cquan==1)||(pquan==2&&cquan==2)||(pquan==3&&cquan==3)) { System.out.println("平局");
}else {
System.out.println(+"win");
c.fen++;
}
System.out.println("是否进入下一轮：");
answer= input.next();
}
}
System.out.println("--------------------");
System.out.println("对战次数："+ci);
System.out.println(+"分数为"+p.fen);
System.out.println(+"分数为"+c.fen);
}
}
text.java
package caiquan;
import java.util.Scanner;
publicclass Test {
publicstaticvoid main (String[]args) {
Game u = new Game ();
u.start();
}
}
*********************
***猜拳开始***
*********************
出拳规则：1，石头 2，剪刀 3，布请选择角色：1，张三2，李四3，王五3
请输入你的姓名：
ee
王五vsee
是否要开始吗？
y
请出拳：1，石头，2.剪刀3.布
1
你出拳为石头
王五出拳为石头
平局
是否进入下一轮：
y
请出拳：1，石头，2.剪刀3.布
2
你出拳为剪刀
王五出拳为剪刀
平局
是否进入下一轮：
y
请出拳：1，石头，2.剪刀3.布
3
你出拳为布
王五出拳为剪刀
王五win
是否进入下一轮：
n
--------------------
对战次数：3
ee分数为0
王五分数为1
类的带参方法
参数的传递：
JAVA中传递任何东西都是值传递，且只有这一种参数传递方式，如果传入方法是基本类型或引用的东西，就得到此基本类型或引用的一份拷贝。

定义带参的方法：形参必须要有数据类型
调用带参类型方法：实参，传入值，不带数据类型。

publicclass t1 {
public String A(String name) {
String newStr= name+"!";
return newStr;
}
}
publicclass t2 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
t1 A = new t1();
String name = " hello "; //将hello传入t1中去
name = A.A(name); //在对象A中调用A方法
System.out.println(name);
}
}
可以带多个参数，注意他们的顺序和数据类型即可。

用包组织程序
解决类的同名问题相当于一个文件夹
建立工程，建立一个类，在类中选择加入到哪个包
包名由小写字母组成，不能以原点开头或者结尾。

创建了包cn.b.shuguo即创建了目录cn/b/sunguo
使用不在同一包中的类需要import，创建一个包就要引入一个包。

inport java.util.*表示导入java.util包中所有的类。

Inport包名.aaa表示引入该包下的aaa类，import语句要在packet语句后使用。

练习
package com.bank;
import static ng.System.out;
import java.util.Scanner;
public class Account {
int money = 0;
public void start() {
Scanner input = new Scanner(System.in);
while(true) {
out.println("1存款 2取款 3退出");
out.println("请选择要办理的业务：");
switch(input.nextInt()) {
case 1:
out.println("请输入存款金额");
int jin = input.nextInt();
cun(jin);
break;
case 2:
out.println("请输出取款金额：");
jin=input.nextInt();
qu(jin);
break;
case 3:
out.println("谢谢使用再见");
return ; // break是跳出switch循环，return是终止整个方法}
out.println("余额为："+money);
}
}
public void cun(int jin) {
money+=jin;
out.println("存款成功");
out.println();
}
public void qu(int jin) {
if(money>=jin) {
money-=jin;
out.println("取款成功");
out.println();
}else {
out.println("余额不足");
}
}
}
//存钱
package com.bank;
publicclass text {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
Account ac = new Account();
ac.start();
}
}
1存款 2取款 3退出
请选择要办理的业务：
1
请输入存款金额
100
存款成功
余额为：100
1存款 2取款 3退出
请选择要办理的业务：
2
请输出取款金额：
100
取款成功
余额为：0
1存款 2取款 3退出
请选择要办理的业务：
3
谢谢使用再见
字符串
使用String对象存储字符串，String位于ng包中具有丰富的方法：计算字符串长度，比较字符串，连接字符串，提取字符串等。

Str.length() 可用于计算字符串长度，即字符串的字符的个数。

汉字一个算是一个字符判断字符串是否一致使用equals()方法，==判断的是两个字符串的内存位置，判断两者是否为同一对象。

判断.java文件名是否正确，判断邮箱格式是否正确
分析：合法的文件名应该以.java结尾。

合法的邮箱名至少要包含“@”，“.”，并检查@是否在.之前。

publicclass t1 {
publicstaticvoid main(String []args) {
String str = "abc@";
// int i = str.indexOf("a"); 查找不存在的字符运行结果为-1
// System.out.println(i);
//
if(str.indexOf("@")>=0&&str.indexOf(".")>str.indexOf("@")) { System.out.println("ok");
}else {
System.out.println("no");
}
}
}
验证座机号手机号，身份证号是否正确
判断座机电话号码是按照字符“-”的符号进行拆分然后判断长度
Split的用法
publicclass t2 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
String str ="123-4567";
String s[]=str.split("-");
System.out.println(s[0]);
System.out.println(s[1]);
}
}
判断一个字符串中出现几次字符
publicclass t2 {
publicstaticvoid main(String[] args) {
String str = "ahdiehffdkfnaafafkjgh";
int i =0;
while(str.indexOf("a")>=0) {
str = str.substring(str.indexOf("a")+1);
i++;
}
System.out.println(i);
}
}
思路：相当于一根树枝，在a处折断，折断了几次即a出现了多少次。

StringBuffer 类
超级字符串StringBuffer，长度，内存都可以更改的字符串。

创建空的StringBuffer对象（他是一个类需要创建对象）
创建一个变量存储字符串aaa
Append（）末尾处拼接
package text12;
publicclass t1 {
publicstaticvoid main(String[] args){
StringBuffer sb = new StringBuffer("1234");
sb.insert(4,"-");
System.out.println(sb);
}
}
1234-
package text12;
import java.util.Scanner;
publicclass t1 {
publicstaticvoid main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入数字：");
String str = input.next();
StringBuffer sb = new StringBuffer(str);
for(int i = str.length()-3;i>0;i-=3) {
sb.insert(i, ",");
}
System.out.println(sb);
}
}
请输入数字：
123456
123,456
对象数组
苹果类型的数组，苹果是一个自定义的类型
Public class apple {
String color;
Int weight;
Public void green(){
System.out.printLn();
}
package text12;
publicclass t2 {
publicstaticvoid main(String[] args) {
//数组的声明为 intarr[]=new int [4];而新声明的这个数组全是Apple类型
Apple arr[] = new Apple[4]; //一个口袋
//四个苹果
Apple a1 = new Apple();
a1.color = "黑色" ;
a1.weight = 10;
Apple a2 = new Apple();
a2.color = "白色" ;
a2.weight = 20;
Apple a3 = new Apple();
a3.color = "红色" ;
a3.weight = 30;
Apple a4 = new Apple();
a4.color = "旅色" ;
a4.weight = 40;
//苹果入袋
arr[0] = a1;
arr[1] = a2;
arr[2] = a3;
arr[3] = a4;
for (int i =0;i<arr.length;i++) {
arr[i].print();
}
}
}
package text12;
publicclass Apple {
String color;
int weight;
publicvoid print() {
System.out.println(color+"的苹果重量是"+weight);
}
}
黑色的苹果重量是10
白色的苹果重量是20
红色的苹果重量是30
旅色的苹果重量是40
例题：四篇文章按照浏览的顺序进行排序
package test;
publicclass testwen {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
wen w1= new wen() ;
w1.see=111;
w1.title= "我爱JAVA";
wen w2= new wen() ;
w2.see=99;
w2.title= "我爱拉篮球";
wen w3= new wen() ;
w3.see=666;
w3.title= "我爱编程";
wen ws[] = new wen [3];
ws[0]= w1;
ws[1]= w2;
ws[2]= w3;
wen text = new wen();
text.sort(ws);
}
}
package test;
publicclass wen {
String title;
int see;
publicvoid print() {
System.out.println("标题"+title+"浏览"+see+"次");
}
publicvoid sort (wen ws[]) {
for ( int i = 0;i<ws.length;i++) {
for ( int j = 0;j<ws.length-1;j++) {
if(ws[j].see<ws[j+1].see) {
wen temp ;
temp=ws[j];
ws[j]= ws[j+1];
ws[j+1]=temp;
}
}
}
for (int i = 0;i<ws.length;i++) {
ws[i].print();
}
}
}
标题我爱编程浏览666次
标题我爱JAVA浏览111次
标题我爱拉篮球浏览99次
注意对象数组里面装的是对象，输出的也是对象不是基本类型，比较的是浏览次数，不是数组本身。

值传递和引用传递
值类型：基本数据类型
修改值
引用类型：除了基本数据类型之外都是引用类型
输出结果张和李都发生变化，将一个引用传送给了另一个引用，两者指向的仍然是同一个内存空间，通过数组复制解决以上问题。

使用引用传递：
值传递传递的是值而非地址，将值传递给方法，在方法中被改变，值本身不会改变。

引用传递：你用的就是我的，你改我也改，引用传递的是地址，即指针。

第六章抽象与封装
构造与重载
构造方法：与类名一致没有返回值的方法
Dog dog = new Dog();
有双引号就是字符串，有小括号就是调用方法
构造方法名称一致，参数个数类型不一致，即构造重载，与方法的返回值，访问修饰符无关。

静态关键字Static
静态变量：
对于属于人类的个体来说，地球是属于每个人类的，成为静态变量。

所谓静态即内存中只有一份，他属于类，不随对象的创建而建立副本，可被该类中所有对象共享。

静态方法里不能使用this关键字。

This指的是类的本身，它是属于对象的，静态成员变量是属于类的，对象存在的时候静态成员变量一定存在，但this 不知道指向的是哪个对象，静态成员变量存在的时候对象不一定存在。

package test;
class A {
int i = 1; // 成员变量,属于每一个对象，每一个对象都有自己的值
}
publicclass wen {
publicstaticvoid main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.i=2;
System.out.println(a1.i);
A a2 = new A ();
System.out.println(a2.i);
}
}
1
2
1
package test;
class A {
staticint i = 1; // 静态变量,属于类级别，每一个对象公用同一个静态变量}
publicclass wen {
publicstaticvoid main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.i=2;
System.out.println(a1.i);
System.out.println("----------");
A a2 = new A ();
System.out.println(a2.i);
}
}
1
2
----------
2
package test;
class A {
staticint i = 1; // 静态变量,属于类级别，每一个对象公用同一个静态变量staticpublicvoid a () { //静态方法
System.out.println("aaa");
}
}
publicclass wen {
main(String[] args) {
new A();
A a2 = new A ();
A.a(); // 静态方法的调用，未使用静态方法时用 a1.a表示
}
}
静态代码块：
package test;
publicclass wen {
// 静态代码块具有最高的优先级，在类加载的时候就已经执行了
static {
System.out.println("1");
}
publicvoid a1() {
System.out.println("2");
}
publicstaticvoid a2() {
System.out.println("3");
}
publicstaticvoid main(String[] args) {
wen t1 = new wen();
t1.a1();
a2(); // main 方法也是静态，两个静态方法之间相互调用使用方法名即可}
}
输出：123
除了使用静态变量和方法之外，类的变量和方法只能通过对象的引用来进行调用，但在类的内部可以不通过对象引用成员变量和方法，即使用关键字this，表示此类本身，它只能在方法里使用，且不能在修饰为static的方法中使用。

创建对象的引用是谁，this就是谁。

Test t = new Test();即创建test类的对象实例，且引用为t。

第七章面向对象
封装
将类的某种信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装好比一个盒子，将东西都装起来，让外界能看到这些东西，封装就是在一个类里面定义了一些成员变量和方法并且限制他们的可见性，使外界不能访问他们，因此封装展现了接口隐藏了细节。

封装的成员变量的标识一般为private
例：通过把bike类的各个成员变量声明为私有型，可以让父类和其他类不能访问，只需要提供给外界get，set方法进行操作，当外界操作时不需要知道具体的实现细节，只需要了解返回值是什么即可。

封装的步骤：
package test;
class Dog {
privateint health;
publicvoid setHealth(int h ) {
health = h ; //this.health = h ;通过set方法设置health的值}
publicint getHealth() { //通过get方法使外界获取health的值
return health;
}
}
publicclass wen {
publicstaticvoid main(String[] args) {
Dog d = new Dog();
d.setHealth(66);
System.out.println("健康值"+d.getHealth());
}
}
多个方法的时候：
Alt+shift+s 快捷封装
选择getters and setters
This 指的是当前封装的声明
调用构造时必须是整个方法中的第一句代码
例题
package test;
import java.util.Scanner;
class Person{
private String name ;
privateint age;
public String getName() {
return name;
}
publicvoid setName(String name) {
= name;
}
publicint getAge() {
return age;
}
publicvoid setAge(int age) {
if(age>0&&age<=150) {
this.age = age;
}else {
System.out.println("数值错误恢复默认");
this.age= 18;
}
}
publicvoid print () {
System.out.println("name"+name+"age"+age);
}
}
publicclass Text {
publicstaticvoid main(String[] args) {
Person p = new Person();
System.out.println("请录入会员信息");
Scanner input = new Scanner(System.in);
System.out.println("请输入姓名");
p.setName(input.next());
System.out.println("请输入年龄");
p.setAge(input.nextInt());
p.print();
}
}
Final修饰变量的含义指该变量一旦被初始化之后就不允许再被修改，final关键字修饰成员变量，其值是不能修改的，必须初始化，被final修饰的变量是不能被默认初始化的。

对于引用类型，一旦为其赋值就不能重新引用另外一个对象。

当其修饰方法时，被修饰的方法能被该类额子类所继承，不能重写，这样保护了父类的某些特殊数据。

继承
为什么用继承：如果两个对象有一部分相同的属性的时候，将相同的属性放在一起称为父类，形成继承之后父类的资源可以享用。

构造器的作用：确保每一个对象都能得到初始化，没有返回值
被修饰为static类型的方法是一个类方法，子类出现同名方法时父类不会被覆盖。

Public door(){
This.color = “yellow”;
}
package test;
publicclass Player extends Fa{
String id ;
}
package test;
publicclass TE {
publicstaticvoid main(String[] args) { Player p = new Player();
p.hp =100;
}
}
package test;
publicclass Fa {
String name ;
int hp;
int lv;
int mp;
}
// 只能继承一个父类
传递性：
package test;
class A {
int a ;
publicvoid a() {
}
}
class B extends A {
publicvoid b() {
super.a();
}
}
publicclass TE {
publicstaticvoid main(String[] args) {
A a =new A();
B b =new B();
b.a=10;
}
}
不同包下的默认修饰符不能被继承，需要公开，即在数据类型或方法之前加上Public
Main方法是程序的入口
程序执行子类构造的时候一定也会调用父类构造，并且首先调用父类构造
方法重写
继承了父类，但不需要父类的规定，子类有自己的实现，就叫做重写
package test;
class A {
public String say() {
return"握手";
}
}
class USA extends A{
public String say() {
return"拥抱";
}
}
publicclass TE {
publicstaticvoid main(String[] args) {
A a =new A();
USA u =new USA ();
System.out.println(u.say());
}
}
输出：拥抱
方法重写的规则：
方法名相同，参数列表相同，返回值类型相同或是其子类，访问权限不能严于父类父类访问权限为默认，则重写权限只能public
Super关键字来访问父类成员
Super只能出现在子类的方法和构造方法中
Super调用构造方法时只能是第一句，
Super不能访问父类的private成员
象类和抽象方法
抽象类不能被new
Abstract 也可以用于方法--抽象方法
抽象方法没有方法体
抽象方法必须在抽象类里面
抽象方法必须在子类中被实现，除非子类是抽象类
抽象类需要其他类继承来实现抽象类中的方法。

抽象类不能实例化。

没有方法体的方法（public abstract void run();）
package test;
abstractclass A {
publicabstractvoid say() ;
}
class TA extends A {
publicvoid say() { // 类型需一致
System.out.println("测试"); // 必须在子类中实现抽象方法}
}
publicclass TE {
publicstaticvoid main(String[] args) {
TA a =new TA(); // 抽象类不能new新对象
a.say(); //子类中可以调用抽象方法
}
}
通常在继承关系中父类为了规范代码，或者父类本身被new出来并没有实际意义我们就将其设置为抽象类
Final
最终类不能作为父类，方法也不能被重写，属性值不能被修改，即不能被重新赋值，使用常量，常量名通常使用大写区分
没有任何区别但是第二个最规范
方法的重写：在子类本身的方法中，如果有和所继承的方法有一样的名字，就构成了方法的重写，重写的特点就是能够为子类定义特有的行为。

方法的重载：在一个类中有两个或者两个以上有相同名字不同参数的方法。

静态方法不能被重写。

若SON继承了MATH，math m = new Son();就能实现静态的覆盖，这是由于对象引用m在运行期间被强制转换成math类型。

重写toString方法：次方法是Object类方法，该方法返回的是对象信息，如果需要得到比较详细的状态信息，就要对toString 方法进行重写。

Public String toString(){
Return ....
}
重写equals方法：此方法也是Object类，重写是为了比较两个对象的内容是否相等，两个比较对象都指向同一个对象的时候才会返回真值，如果需要进行比较详细的判断，就需要对方法进行重写。

抽象与继承的关系：设计的图纸好比一个抽象类，而需要把房子盖起来实现这个图纸，抽象类中至少含有一个方法，让他的子类实现抽象方法，抽象类永远不能被实例化。

多态实现
例如苹果和馒头，苹果属于水果而馒头属于面食，他们两个都可以属于食物，即一种物品有多种表现状态。

多态是基于继承的。

枚举类：就好像封装了一些成员变量，提高开发的效率。

Public enum Grade{
A,B,C,D};
Instanceof字面上可理解为检查实例，返回结果是boolean类型，如果返回是ture，则说明对象的引用是该对象所指的类和接口 if (对象引用 instanceof 类或接口)
接口的多态实现：
package t3;
//创建food接口
interface food {
pu blic void getName();//得到食物的名称
publicvoid eat();//吃食物的方法
}
//创建fruit food接口继承food
interface fruit extends food{
}
interface meat extends food{
}
//创建类继承接口
class ora implements fruit{
//实现接口里的所有方法
publicvoid getName(){
System.out.println("橘子");
}
publicvoid eat(){
System.out.println("吃橘子");
}
}
class hotpot implements meat{
publicvoid getName(){
System.out.println("羊肉");
}
publicvoid eat(){
System.out.println("吃羊肉");
}
}
//总的测试类
publicclass bike {
publicstaticvoid main(String[] args) { //创建橘子实例
food o = new ora();
o.eat();
o.getName();
//创建羊肉实例
food h = new hotpot();
h.eat();
h.getName();。