java基础以及面向对象的一些笔记
标识符（可以自己取名字的）关键字不能作为标识符，是以字母下划线“_”或美元符号$开始的。
变量：java中保存数据的最小单元。
注意：变量必须先声明再赋值才能使用
变量按位置划分分为成员变量和局部变量（声明在方法中的为局部变量，其他的为成员变量）
按数据类型来分分为基本数据类型和引用数据类型
基本数据类型分为四类八种
局部变量的作用域：在哪个大括号里声明，就只能在这对大括号里使用
字符类型char 占两个字节可以保存中文，使用的是unicode编码，本质上就是整数 AscII码（美国标准信息交换码）中国 ＧＢ２３１２ ＧＢｋ ＧＢ１８０３０； 台湾：ｂｉｇ－５；
布尔类型boolean ture flase
整数类型byte short int long（分这么多是为了节省内存）
bit位（01）一个0一个1代表1位
byte字节 8bit=1byte；范围是（-128，127）共有256个不同的数（1 111111）其中1代表符号-（0 1111111）其中0为+
short int long 计算取值范围同上 short能表示65536个不同的数字
1024byte=1kb 1mb=1024kb 1gb=1024mb 1TB=1024gb
浮点类型float（单精度）double（双精度）
整数的常量默认为int，如果要表示long类型的常量一定要加l
浮点类型的常量默认为是double，要表示float一定要加f
数据类型的转换注意事项
1.boolean类型不能转换为其他的数据类型
2.小的自动转化成大的，大的要转换成小的必须加强制类型转换且注意溢出问题
（byte short char int long float double）
例1（小转大部分代码）：int a = 10;
long b = a;
System.out.println(b);
例2（大转小部分代码）
double a = 10;
int b = (int)a;
溢出问题
int a = 128;
byte b =(byte)a;
//因为byte的最大值为127所以溢出
3.在混合运算中，所有的类型先转换成最大的那个之后在进行运算
int a = 128;
byte c = 12;
float d =12.4f;
float f= a+b+d;
//先将所有的类型先转换成最大的folat在进行计算
4.byte short char 类型 之间不能进行转换，且这三种类型参加运算先把自己转换成int类型在进行运算
char c = ‘a’;
char b = ‘d’;
c+b;
//结果为int类型
三目条件运算符
X？Y：Z
x是布尔表达式
如果x为真，则结果为y，否则结果为z
public class HelloWorld{
public static void main(String args[]){
int c =10>3?'f':'y';
System.out.println("HelloWorld");
System.out.println(c);
}
}
//结果为102；因为这里定义了才为整数类型且字符串其实就是整数
条件分支语句：
if{}
else{}
swihch(){//在jdk7.0前括号里必须是整型表达式
case XX://注意只要有一个case成立，后面不比较直接打印
}
default 当前的条件都不满足
break ：退出switch 整个语句
循环语句
for（循环的初始；循环条件；循环步长）｛｝
1循环的初始值，
2判循环条件是否成立
3成立则执行循环体中的内容
4.步长
5判断循环条件是否成立。。。
直到循环条件不成立
死循环结束 ：ctrl+c
while 循环
int a = 1;
while (a<7){
System.out.println(“*****”);
a++;
}
在扩号里只写循环条件
do{}
while(){}
一开始就执行do语句里面的，然后在执行while语句
控制语句：
continue break
continue:应用在循环语句中，跳出当前循环的本次循环，继续执行下一次循环
break：在循环语句时，指的是跳出当前循环的整个循环；
在switch分支语句中，跳出当前的switch
JAVA方法：
出现的原因：代码的复用，即进行封装
方法的组成：访问修饰符 返回值类型 方法名(参数列表) {方法体}
递归算法：
用途：一般用来解决树形结构的问题
特点：方法调用了其本身
下面就是几个关于for循环的算法的例子
1.求1+2+...+100
public class Suanfa {
public static void main(String args[]){
/*方法一
int a = 1;
int b = 2;
for(;b<=100;){
a = a + b;
b++;
}
System.out.println(a);
*/
//方法二
int sum = 0;
for(int i=1;i<=100;i++){
sum = sum + i;
}
System.out.println(sum);
}
}
2. 数列1 1 2 3 5 8...求第二十一个的值
public class Suanfa2 {
public static void main(String args[]) {
int a = 1;
int b = 1;
for(int i=1;i<=19;i++) {
int c = 0;
c = a;
a = b;
b = c + a;
}
System.out.println(b);
}
}
3.打印*
**
***
****
*****
******
*******
********
*********
public class Suanfa3 {
public static void main(String args[]){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
4.打印上题倒着的
public class Suanfa4 {
public static void main(String args[]) {
for(int i=9;i>=1;i--){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
5.打印出
public class Suanfa5 {
public static void main(String args[]){
/*for(int i=5;i>=1;i--){
for(int j=1;j<i;j++){
System.out.print(" ");
}
for(int a=1;a<=11;a++){
if(a>2*i) {
System.out.print("*");
}
}
System.out.println();
}*/
int b =1;
for(int i=5;i>=1;i--){
for(int j=1;j<i;j++){
System.out.print(" ");
}
for(int a=1;a<=b;a++){
System.out.print("*");
}
System.out.println();
b=b+2;
}
}
}
6.打印出99乘法表
public class Suanfa6 {
public static void main(String args[]) {
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+j*i+" ");//加号连接“”
}
System.out.println();
}
}
}
7.打印出100到200之间的质数
public class Suanfa8 {
public static void main(String args[]) {
for(int i=101;i<200;i++){
for(int j=2;j<i;j++){
if(i%j==0){
break;
}
else if(j==(i-1)){
System.out.println(i);
}
}
}
}
}
8，用递归法做第二题
public class Suanfa7 {
public static void main(String args[]) {
System.out.println(m(21));
}
public static int m(int n){
if(n==1||n==2){
return 1;}
else
return m(n-1)+m(n-2);
}
}
对象：一切皆对象，由属性（名词）和行为（动词）组成。
类:具有相同属和行为的一组对象的集合
对象是具体存在的，类是抽象的。类是具体对象的模版。
属性：成员变量
行为：方法
同一文件只有一个类是public（main方法的）
创建对象：new+ 构造方法
如 Person p = new Person();
构造方法：1.名字和类名一模一样
2.没有返回值类型，连void都没有
3 .每一个类都有一个空的隐式的构造方法
4.如果手动的去写一个显式的构造方法，那么隐式的构造 方法就不存在了
5.构造方法的作用就是用来创建对象的，不能调用（对象. 点方法名（）;）
作用：可以用来初始化成员变量 （创建一个显式的方法）例题在下面
this 指针（引用）：区分成员变量和局部变量 加上this.的都是成员变量 相当于内存
|
code segment |
|
stack |
|
heap |
|
static |
代码区保存的是字节码
栈区保存的是局部变量
堆区保存的是对象
静态区（栈区里分出来的一小块内存）保存的是静态的常量以及字符串常量
栈和堆的区别都是先进后出 后进先出
栈里面保存的数据比较小 数度快
堆保存大数据 速度慢
成员变量的值伴随着对象保存在堆区里面
null值 ：引用没用保存任何对象的内存地址（引用没有只想任何对象）
一个对象没有被引用就相当于再也找不到这块内存，也就是垃圾。可以马上被垃圾回收机制回收，所以我们今后想要把一个对象销毁，最简单的方法就是把他的值设为null值
this和构造方法初始化化成员变量的例子
public class Test {
public static void main(String args[]) {
Person p = new Person("张三");
p.sleep();
}
}
class Person{
String name;
public Person(String name){
this.name = name;
}
public void sleep(){
System.out.println(name+" is sleeping");
}
}
面向对象思考问题的方式：
1.找出有多少个对象
2.根据找到的对象抽取多少个类
3.找出类中有什么样的属性和方法
4，最后创建对象，调用方法完成实际的功能
//张三吃了李四的一根头发
public class T3 {
public static void main(String args[]) {
Person p1 = new Person();
p1.name = "张三";
Person p2 = new Person();
p2.name = "李四";
Hair h = new Hair();
h.info = "李四的一根头发";
p2.h = h;
p1.eat(p2.h);
}
}
class Person {
String name;
Hair h;
public void eat(Hair h){
System.out.println(name+"吃了"+h.info);
}
}
class Hair {
String info;
}
java里先写类，在通过类来创建对象
static 关键字加上static就是静态的
static里面的数据是不能重复的，没一个对象用的成员变量都是一样的
静态的变量：类变量 共享的
类名.类变量名
类名.类方法
都是不需要创建对象直接使用的
main方法为什么是static
main方法是程序的入口，在它执行之前没有任何任何对象被创建，否则就不是程序的入口了。访问一个对象的属性和方法一定要有对象才能访问。
不加static的一定要有对象的才能调用。
关于static的一些程序
//张三买了一张床
public class Test2 {
public static void main(String args []){
Bed.info="一张床";
String b = Bed.info;
Person.name="张三";
Person.sleep(b);
}
}
class Person {
static String name;
public static void sleep(String b){
System.out.println(name+"买了"+b);
}
}
class Bed {
static String info;
}
java是开源的（开放源代码）
类的全名：包名+类名
没有包的类是裸体类。
import（java中导包的）
java.lang 的类不需要导包
com.....
面向对象的三大基本特征：
1封装
代码的复用，屏蔽底层细节
2继承
extends关键字
子类自动拥有父类的所有成员
代码的复用
什么是一种什么
功能的扩展
单继承
3，多态（动态绑定）
必要条件三个：
- 继承
- 方法的重写
- 父类的引用指向子类的对象
比如
p.playwithAnimal(dog或者cat);
访问修饰符
按严格要求从高到低的程度
私有的：private 只能在该类中的使用
默认的： 在同一包的类能互相访问
受保护的： protected 在同一包的类能互相访问但是别的调用的两个类是继承关系就可以使用
公共的：public哪都可以用的；
方法的重写（方法的覆盖 override、
overwrite）
1，发生在继承关系里
2.子类中的重写方法和超类中被重写的方法必须拥有相同的返回值类型，相同的参数列表
3.访问的修饰符可以不一样，但是子类中重写的方法不能有笔超类中被重写的方法更严格的访问修饰符。
super指针：当前对象父类的引用
this指针：当前对象的引用
super. 方法名（）在方法的重写中调用父类的方法
super.成员变量 子类和父类成员变量重名
super（）；调用父类的构造方法
创建子类的对象一定要先构造一个父类的对对象，这样子类才能拥有父类的员。创建对象一定要使用构造方法，java在创建子类的对象时，默认使用的是父类没有参数的构造方法当子类的构造方法需要调用父类的构造方法的时候，supe（）一定要写在子类构造方法的第一行（先有老子再有儿子）
继承和方法的重写以及super指针的例子
/*结果为：animal is sleepping
dog is sleepping
3*/
public class T4 {
public static void main(String args[]) {
Dog dog = new Dog();
dog.sleep();
}
}
class Animal {
public Animal(String name){
this.name = name;
}
String name;
int age = 1;
void sleep(){
System.out.println("animal is sleepping");
}
}
class Dog extends Animal {
public Dog(){
super("zhangsan");
}
public void sleep(){
int age = super.age + 2;
super.sleep();
System.out.println("dog is sleepping");
System.out.println(age);
}
}
方法的重载（overloaded）
- 发生在同一个类里面
- 重载的方法和被重载的方法必须拥有相同的方法名；可以拥有不同的返回值类型，必须拥有不同的参数列表
回答方法的重载和重写的区别：就是方法的重载和重写的12点
//输出的结果为3
public class Test {
public static void main(String args[]) {
A.m(1,1,1);
}
}
class A{
public static void m(int a ,int b){
System.out.println(a+b);
}
public static void m(int a ,int b,int c){
System.out.println(a+b+c);
}
}
Object 类所有java中的根类
- System.out.println会自动调用toString() 因为控制台上只能打印字符串，
- 在出现连接符（+）号的时候也会自动调用toString
==号是比较占占栈区里的东西（引用）
equals 比较对象（XX.equals()）
自己写的类比较规则重写equals 方法
//运行结果为ture
public class T5 {
public static void main(String args[]) {
Person p1 = new Person("tom",22);
Person p2 = new Person("tom",22);
System.out.println(p1.equals(p2));
}
}
class Person {
public Person(String name,int age){
this.name=name;
this.age=age;
}
String name;
int age;
public boolean equals(Object obj){
Person p = (Person)obj;
if(this.name.equals(p.name)&&this.age==p.age){
return true;
}else {
return false;
}
}
}
相等的对象必须具有相同的哈希码（处理东西快）
当equals方法重写时，有必要重写hashCode方法
在上述程序后面加
public int hashCode(){
return this.name.hashCode();
}
Java中父类的引用可以指向子类的对象，但不能使用子类多出来的方法
Anmal cat = new eat (); 向上转型（父类的引用指向子类的对象）
Cat c = (Cat)cat; 向下转型（强制类型转换）
//打印结果为 anlimal is sleepping
//paly
public class Test{
public static void main(String args[]){
Animal cat = new Cat();//父类的引用指向子类的对象
cat.sleep();
Person p =new Person();
p.playWithAnimal(cat);//这里就是多态
}
}
class Animal {
String name;
public void sleep(){
System.out.println("animal is sleepping");
}
}
class Cat extends Animal {
String furcolor;
public void catchMouse() {
System.out.println("catchMouse");
}
}
class Dog extends Animal {
}
class Person {
public void playWithAnimal(Animal a){
System.out.println("play");
}
}
当一个类不需要创建对象，作用只是用来被继承的，这个类应该是抽象的 就如上述例题的 Ainmal ，这个时候可以在前面加上abstract关键字 即abstract class Animal
抽象类不能创建对象
抽象方法就是用来被重写（覆盖的）
抽象的方法不能有方法体 如public abstract void enjoy();
注意：具有抽象的方法的类必须是抽象的
抽象的的类中既可以有抽象方法，也可以有非抽象的方法
final int a = 1;final(最终的)不能改变的量即常量
在比如一个变量的值用到很多次的时候使用可方便于改值
final 的类不能继承
final的方法不能被重写
接口（interface） 规则规范标准
- 接口是一种特殊的抽象类
- 只能有常量和抽象方法
- 接口称之为实现，接口可以多实现
- 接口之间叫继承可以多继承
//结果为：bmw is run
public class T6 {
public static void main(String args[]) {
Bmw b = new Bmw();
b.run();
}
}
interface Car {
public void run();
public void stop();
}
interface A{
public void m();
}
class Bmw implements Car,A {
public void run(){
System.out.println("bmw is run");
}
public void stop() {
System.out.println("bmw is stop");
}
public void m(){
}
}
