面向对象

//数组定义
int[] arr= new int[3];//动态初始化
int[] arr={1,2,3,4}; //静态初始化
public static int add(int[] arr){
int sum= 0;
//遍历一组数组 求和
for(int i = 0;i<arr.length;i++){
sum+=arr[i];
}
return sum;
}
public static void main(String[] args){
int res =add(new int[]{1,2,3});
Systen,out,println(res);
}
//二维数组的定义
int[][] arr =new int[3][];
int[][] arr= new int[3][2];
//二维数组的静态初始化
int[][] arr = new int {new int[][]{1,2},[2,3],[3,4,5]};
int [][] arr ={{1,2},{2,3},{3,4,5}}
//一维数组的copy
public static int[] arrCopy(int[] arr){
int[] des =new int [arr.length];
for(int i =0;i<arr.length;i++){
des[i] =aee[i];
}
System.out.println("在方法内，亲创建的目标数组的新地址是： +des");
return des;
}
//************************************
//面对对象。。。。
现实世界中的事物 Java的类>>对象
属性 -->成员变量
行为 -->成员方法
//学生类
class Student{
String name;
int age;
String address;
public void study(){
System.out.println("学习");
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
}
class StudentDemo{
public static void main(String[] args){
//类名 对象名 = new 类名();
Student s = new Student();
//输出成员变量值
// System.out.println(s.name);
// System.out.println(s.age);
// System.out.println(s.address);
System.out.println(s.name + " "+ s.age+" " +s.address);
//成员变量赋值
s.name = "张三";
s.age =16;
s.address ="北京";
//赋值后输出
System.out.println(s.name +" "+s.age+" " +s.address);
//调用方法
s.study();
s.eat();
s.sleep();
}
}
//手机类
class phone{
String brand;
int price;
String color;
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
public void playGame(){
System.out.println("玩游戏");
}
}
class PhoneDemo{
public static void main(String[] args){
Phone p = new Phone();
System.out.println(p.brand+" "+p.price+" "+p.color);
p.brand = "华为";
p.price = "1000";
p.color = "白色";
System.out.println(p.brand +" " +p.price+" " +p.color);
//调用方法
p.call("小李");
p.sendMessage();
p.playGame();
}
}
//匿名对象、
class Student{
public void show(){
System.out.println("I love study");
}
}
class StudentDemo{
public void method(Student s){
s.show();
}
}
class NoNameDemo{
public static void main(String[] arge){
Student s = new Student();
s.show();
s.show();
System.out.println("----------");
//匿名对象
// new Student();
//匿名对象调用方法
new Student().show();
new Student().show();
System.out.println("----------");
//匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
// Student ss = new Student();
// sd.method(ss);//s是实际参数
//匿名对象
sd.method(new Student());
//两个都是匿名对象
new StudentDemo().method(new Student());
}
}
//封装
class Student{
String name ;
private int age;
public void setAge(int a){
if(a<0||age>150){
System.out.println("年龄非法");
}else{
age = a;
}
}
public void show(){
System.out.println("姓名"+name);
System.out.println("年龄"+age);
}
}
class StudentDemo{
public static void main(String[] args){
Student s = new Student();
s.show();
System.out.println("--------------------");
//给成员变量赋值
s.name="林青霞";
s.setAge(27);
s.show();
System.out.println("---------");

}
}
//**************************
private关键字
//特点 ：被private 修饰的成员只能本类才能访问
//  把成员变量用private修饰
//  提供对应的getXxx()/setXxx()方法，这样在类的外部就可以通过公有的方法对这些私有变量进行访问了
class Demo{
private int num = 10;
public void show(){
System.out.println(num);
}
private void method(){
System.out.println("method");
}
public void function(){
method();

}
}
class PrivateDemo{
public static void main(String[] args){
Demo d =new Demo();
d.show();
d.function();
}
}
//Student >>>>>>>>>>>封装和private
// getXxx()和steXxx()方法
class Student{
private Student name;
private int age;
public String getName(){
return name ;
}
public void setName(String n){
name = n;
}
public int getAge(){
return age;
}
public void setAge(int a){
age =a ;
}
}
class StudentText{
public static void main(String[] args ){
Student s =new Student();
System.out.println(s.getName()+" "+s.getAge());
s.steName("tom");
s.setAge(27);
System.out.println(s.getName()+" " +s.getAge());
}
}
//定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试类Test，进行测试。
//方式1
/*class Demo{
public int sum(){
int a =10;
int b = 20;
int c = a+b;
return c;
}
}*/
//方式2
/*class Demo{
public int sum(int a ,int b){
return a + b;
}
}*/
//方式3
class Demo{
int a;
int b;
public int sim(){
return a+b;
}
}
//测试类
public static void main(String[] args ){
//方式1
Demo d = new Demo();
System.out.println(d.sum());
//方式2
Demo d =new Demo();
int a = 10;
int b =20;
System.out.println(d.sum(a,b));
//方式3
Demo d = new Demo();
d.a=10;
d.b=20;
System.out.println(d.sun());
}
//定义一个长方形类rectangle,定义求周长girth和面积area的方法，
//然后定义一个测试类Test2，进行测试。
import java.util.Scanner{
class ChangFangXing{
private int length;
private int width;
public ChangFangXing(){}
public void setLength(int length){
this.length = length;}
public void setWidth(int width){
this.width = width;
}
public int getZhouChang(){
return(length+width)*2;
}
public int getArea(){
return length*width;
}
}
class Test2{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入长方形的长： ");
int length = sc.nestInt();
System.out.println("请输入长方形的宽： ");
int width =sc.nestInt();
ChangFangXing cfx =new ChangFangXing();
cfx.steLength(length);
cfx.steWidth(width);
System.out.println("周长是："+cfx.getZhouChang());
System.out.println("面积是：+cfx.getArea()");

}
}
}

 

1 /*Student s = new Student();>>>>>>>>>>>>>>>>>>>>>>>>>>>>
加载Student.class文件进内存
在栈内存为变量s开辟空间
在堆内存为对象开辟空间
给对象的成员变量进行默认初始化（0/false/null）
给产生的对象的成员变量进行显示初始化（若类中成员变量使用了赋值语句）

通过构造方法对对象的成员变量赋值（如果构造方法中使用了赋值语句）
对象初始化完毕，把实例对象地址（引用）赋值给变量s */
/*2 对象的成员变量的值都可以在哪些地方被赋值？
1. 类加载后，进行初始化的时候（系统赋默认值，无法更改系统规定的赋什么默认值）
2. 在类的定义中显示初始化时（可以根据业务需求）
3. 构造方法中（根据业务需求）
4. 使用对象名.变量名 方式赋值或者是使用setXxx方法赋值（根据业务需求）*/